stacks 0.58.73 → 0.59.2

package/core/desktop/dist/index.js

@@ -1,3081 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// ../../../../node_modules/@tauri-apps/api/shell.js
-var exports_shell = {};
-__export(exports_shell, {
-  open: () => {
-    {
-      return open;
-    }
-  },
-  EventEmitter: () => {
-    {
-      return EventEmitter;
-    }
-  },
-  Command: () => {
-    {
-      return Command;
-    }
-  },
-  Child: () => {
-    {
-      return Child;
-    }
-  }
-});
-
-// ../../../../node_modules/@tauri-apps/api/tauri.js
-var exports_tauri = {};
-__export(exports_tauri, {
-  transformCallback: () => {
-    {
-      return transformCallback;
-    }
-  },
-  invoke: () => {
-    {
-      return invoke;
-    }
-  },
-  convertFileSrc: () => {
-    {
-      return convertFileSrc;
-    }
-  }
-});
-var uid = function() {
-  return window.crypto.getRandomValues(new Uint32Array(1))[0];
-};
-var transformCallback = function(callback, once = false) {
-  const identifier = uid();
-  const prop = `_${identifier}`;
-  Object.defineProperty(window, prop, {
-    value: (result) => {
-      if (once) {
-        Reflect.deleteProperty(window, prop);
-      }
-      return callback?.(result);
-    },
-    writable: false,
-    configurable: true
-  });
-  return identifier;
-};
-async function invoke(cmd, args = {}) {
-  return new Promise((resolve, reject) => {
-    const callback = transformCallback((e) => {
-      resolve(e);
-      Reflect.deleteProperty(window, `_${error}`);
-    }, true);
-    const error = transformCallback((e) => {
-      reject(e);
-      Reflect.deleteProperty(window, `_${callback}`);
-    }, true);
-    window.__TAURI_IPC__({
-      cmd,
-      callback,
-      error,
-      ...args
-    });
-  });
-}
-var convertFileSrc = function(filePath, protocol = "asset") {
-  return window.__TAURI__.convertFileSrc(filePath, protocol);
-};
-
-// ../../../../node_modules/@tauri-apps/api/helpers/tauri.js
-async function invokeTauriCommand(command) {
-  return invoke("tauri", command);
-}
-
-// ../../../../node_modules/@tauri-apps/api/shell.js
-async function execute(onEvent, program, args = [], options) {
-  if (typeof args === "object") {
-    Object.freeze(args);
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Shell",
-    message: {
-      cmd: "execute",
-      program,
-      args,
-      options,
-      onEventFn: transformCallback(onEvent)
-    }
-  });
-}
-async function open(path, openWith) {
-  return invokeTauriCommand({
-    __tauriModule: "Shell",
-    message: {
-      cmd: "open",
-      path,
-      with: openWith
-    }
-  });
-}
-
-class EventEmitter {
-  constructor() {
-    this.eventListeners = Object.create(null);
-  }
-  addListener(eventName, listener) {
-    return this.on(eventName, listener);
-  }
-  removeListener(eventName, listener) {
-    return this.off(eventName, listener);
-  }
-  on(eventName, listener) {
-    if (eventName in this.eventListeners) {
-      this.eventListeners[eventName].push(listener);
-    } else {
-      this.eventListeners[eventName] = [listener];
-    }
-    return this;
-  }
-  once(eventName, listener) {
-    const wrapper = (...args) => {
-      this.removeListener(eventName, wrapper);
-      listener(...args);
-    };
-    return this.addListener(eventName, wrapper);
-  }
-  off(eventName, listener) {
-    if (eventName in this.eventListeners) {
-      this.eventListeners[eventName] = this.eventListeners[eventName].filter((l) => l !== listener);
-    }
-    return this;
-  }
-  removeAllListeners(event) {
-    if (event) {
-      delete this.eventListeners[event];
-    } else {
-      this.eventListeners = Object.create(null);
-    }
-    return this;
-  }
-  emit(eventName, ...args) {
-    if (eventName in this.eventListeners) {
-      const listeners = this.eventListeners[eventName];
-      for (const listener of listeners)
-        listener(...args);
-      return true;
-    }
-    return false;
-  }
-  listenerCount(eventName) {
-    if (eventName in this.eventListeners)
-      return this.eventListeners[eventName].length;
-    return 0;
-  }
-  prependListener(eventName, listener) {
-    if (eventName in this.eventListeners) {
-      this.eventListeners[eventName].unshift(listener);
-    } else {
-      this.eventListeners[eventName] = [listener];
-    }
-    return this;
-  }
-  prependOnceListener(eventName, listener) {
-    const wrapper = (...args) => {
-      this.removeListener(eventName, wrapper);
-      listener(...args);
-    };
-    return this.prependListener(eventName, wrapper);
-  }
-}
-
-class Child {
-  constructor(pid) {
-    this.pid = pid;
-  }
-  async write(data) {
-    return invokeTauriCommand({
-      __tauriModule: "Shell",
-      message: {
-        cmd: "stdinWrite",
-        pid: this.pid,
-        buffer: typeof data === "string" ? data : Array.from(data)
-      }
-    });
-  }
-  async kill() {
-    return invokeTauriCommand({
-      __tauriModule: "Shell",
-      message: {
-        cmd: "killChild",
-        pid: this.pid
-      }
-    });
-  }
-}
-
-class Command extends EventEmitter {
-  constructor(program, args = [], options) {
-    super();
-    this.stdout = new EventEmitter;
-    this.stderr = new EventEmitter;
-    this.program = program;
-    this.args = typeof args === "string" ? [args] : args;
-    this.options = options ?? {};
-  }
-  static sidecar(program, args = [], options) {
-    const instance = new Command(program, args, options);
-    instance.options.sidecar = true;
-    return instance;
-  }
-  async spawn() {
-    return execute((event) => {
-      switch (event.event) {
-        case "Error":
-          this.emit("error", event.payload);
-          break;
-        case "Terminated":
-          this.emit("close", event.payload);
-          break;
-        case "Stdout":
-          this.stdout.emit("data", event.payload);
-          break;
-        case "Stderr":
-          this.stderr.emit("data", event.payload);
-          break;
-      }
-    }, this.program, this.args, this.options).then((pid) => new Child(pid));
-  }
-  async execute() {
-    return new Promise((resolve, reject) => {
-      this.on("error", reject);
-      const stdout = [];
-      const stderr = [];
-      this.stdout.on("data", (line) => {
-        stdout.push(line);
-      });
-      this.stderr.on("data", (line) => {
-        stderr.push(line);
-      });
-      this.on("close", (payload) => {
-        resolve({
-          code: payload.code,
-          signal: payload.signal,
-          stdout: stdout.join("\n"),
-          stderr: stderr.join("\n")
-        });
-      });
-      this.spawn().catch(reject);
-    });
-  }
-}
-
-// ../../../../node_modules/@tauri-apps/api/app.js
-var exports_app = {};
-__export(exports_app, {
-  show: () => {
-    {
-      return show;
-    }
-  },
-  hide: () => {
-    {
-      return hide;
-    }
-  },
-  getVersion: () => {
-    {
-      return getVersion;
-    }
-  },
-  getTauriVersion: () => {
-    {
-      return getTauriVersion;
-    }
-  },
-  getName: () => {
-    {
-      return getName;
-    }
-  }
-});
-async function getVersion() {
-  return invokeTauriCommand({
-    __tauriModule: "App",
-    message: {
-      cmd: "getAppVersion"
-    }
-  });
-}
-async function getName() {
-  return invokeTauriCommand({
-    __tauriModule: "App",
-    message: {
-      cmd: "getAppName"
-    }
-  });
-}
-async function getTauriVersion() {
-  return invokeTauriCommand({
-    __tauriModule: "App",
-    message: {
-      cmd: "getTauriVersion"
-    }
-  });
-}
-async function show() {
-  return invokeTauriCommand({
-    __tauriModule: "App",
-    message: {
-      cmd: "show"
-    }
-  });
-}
-async function hide() {
-  return invokeTauriCommand({
-    __tauriModule: "App",
-    message: {
-      cmd: "hide"
-    }
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/event.js
-var exports_event = {};
-__export(exports_event, {
-  once: () => {
-    {
-      return once2;
-    }
-  },
-  listen: () => {
-    {
-      return listen2;
-    }
-  },
-  emit: () => {
-    {
-      return emit2;
-    }
-  },
-  TauriEvent: () => {
-    {
-      return TauriEvent;
-    }
-  }
-});
-
-// ../../../../node_modules/@tauri-apps/api/helpers/event.js
-async function _unlisten(event, eventId) {
-  return invokeTauriCommand({
-    __tauriModule: "Event",
-    message: {
-      cmd: "unlisten",
-      event,
-      eventId
-    }
-  });
-}
-async function emit(event, windowLabel, payload) {
-  await invokeTauriCommand({
-    __tauriModule: "Event",
-    message: {
-      cmd: "emit",
-      event,
-      windowLabel,
-      payload
-    }
-  });
-}
-async function listen(event, windowLabel, handler) {
-  return invokeTauriCommand({
-    __tauriModule: "Event",
-    message: {
-      cmd: "listen",
-      event,
-      windowLabel,
-      handler: transformCallback(handler)
-    }
-  }).then((eventId) => {
-    return async () => _unlisten(event, eventId);
-  });
-}
-async function once(event, windowLabel, handler) {
-  return listen(event, windowLabel, (eventData) => {
-    handler(eventData);
-    _unlisten(event, eventData.id).catch(() => {
-    });
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/event.js
-async function listen2(event2, handler) {
-  return listen(event2, null, handler);
-}
-async function once2(event2, handler) {
-  return once(event2, null, handler);
-}
-async function emit2(event2, payload) {
-  return emit(event2, undefined, payload);
-}
-var TauriEvent;
-(function(TauriEvent2) {
-  TauriEvent2["WINDOW_RESIZED"] = "tauri://resize";
-  TauriEvent2["WINDOW_MOVED"] = "tauri://move";
-  TauriEvent2["WINDOW_CLOSE_REQUESTED"] = "tauri://close-requested";
-  TauriEvent2["WINDOW_CREATED"] = "tauri://window-created";
-  TauriEvent2["WINDOW_DESTROYED"] = "tauri://destroyed";
-  TauriEvent2["WINDOW_FOCUS"] = "tauri://focus";
-  TauriEvent2["WINDOW_BLUR"] = "tauri://blur";
-  TauriEvent2["WINDOW_SCALE_FACTOR_CHANGED"] = "tauri://scale-change";
-  TauriEvent2["WINDOW_THEME_CHANGED"] = "tauri://theme-changed";
-  TauriEvent2["WINDOW_FILE_DROP"] = "tauri://file-drop";
-  TauriEvent2["WINDOW_FILE_DROP_HOVER"] = "tauri://file-drop-hover";
-  TauriEvent2["WINDOW_FILE_DROP_CANCELLED"] = "tauri://file-drop-cancelled";
-  TauriEvent2["MENU"] = "tauri://menu";
-  TauriEvent2["CHECK_UPDATE"] = "tauri://update";
-  TauriEvent2["UPDATE_AVAILABLE"] = "tauri://update-available";
-  TauriEvent2["INSTALL_UPDATE"] = "tauri://update-install";
-  TauriEvent2["STATUS_UPDATE"] = "tauri://update-status";
-  TauriEvent2["DOWNLOAD_PROGRESS"] = "tauri://update-download-progress";
-})(TauriEvent || (TauriEvent = {}));
-
-// ../../../../node_modules/@tauri-apps/api/clipboard.js
-var exports_clipboard = {};
-__export(exports_clipboard, {
-  writeText: () => {
-    {
-      return writeText;
-    }
-  },
-  readText: () => {
-    {
-      return readText;
-    }
-  }
-});
-async function writeText(text) {
-  return invokeTauriCommand({
-    __tauriModule: "Clipboard",
-    message: {
-      cmd: "writeText",
-      data: text
-    }
-  });
-}
-async function readText() {
-  return invokeTauriCommand({
-    __tauriModule: "Clipboard",
-    message: {
-      cmd: "readText",
-      data: null
-    }
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/dialog.js
-var exports_dialog = {};
-__export(exports_dialog, {
-  save: () => {
-    {
-      return save;
-    }
-  },
-  open: () => {
-    {
-      return open2;
-    }
-  },
-  message: () => {
-    {
-      return message;
-    }
-  },
-  confirm: () => {
-    {
-      return confirm;
-    }
-  },
-  ask: () => {
-    {
-      return ask;
-    }
-  }
-});
-async function open2(options = {}) {
-  if (typeof options === "object") {
-    Object.freeze(options);
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Dialog",
-    message: {
-      cmd: "openDialog",
-      options
-    }
-  });
-}
-async function save(options = {}) {
-  if (typeof options === "object") {
-    Object.freeze(options);
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Dialog",
-    message: {
-      cmd: "saveDialog",
-      options
-    }
-  });
-}
-async function message(message2, options) {
-  const opts = typeof options === "string" ? { title: options } : options;
-  return invokeTauriCommand({
-    __tauriModule: "Dialog",
-    message: {
-      cmd: "messageDialog",
-      message: message2.toString(),
-      title: opts?.title?.toString(),
-      type: opts?.type,
-      buttonLabel: opts?.okLabel?.toString()
-    }
-  });
-}
-async function ask(message2, options) {
-  const opts = typeof options === "string" ? { title: options } : options;
-  return invokeTauriCommand({
-    __tauriModule: "Dialog",
-    message: {
-      cmd: "askDialog",
-      message: message2.toString(),
-      title: opts?.title?.toString(),
-      type: opts?.type,
-      buttonLabels: [
-        opts?.okLabel?.toString() ?? "Yes",
-        opts?.cancelLabel?.toString() ?? "No"
-      ]
-    }
-  });
-}
-async function confirm(message2, options) {
-  const opts = typeof options === "string" ? { title: options } : options;
-  return invokeTauriCommand({
-    __tauriModule: "Dialog",
-    message: {
-      cmd: "confirmDialog",
-      message: message2.toString(),
-      title: opts?.title?.toString(),
-      type: opts?.type,
-      buttonLabels: [
-        opts?.okLabel?.toString() ?? "Ok",
-        opts?.cancelLabel?.toString() ?? "Cancel"
-      ]
-    }
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/fs.js
-var exports_fs = {};
-__export(exports_fs, {
-  writeTextFile: () => {
-    {
-      return writeTextFile;
-    }
-  },
-  writeFile: () => {
-    {
-      return writeTextFile;
-    }
-  },
-  writeBinaryFile: () => {
-    {
-      return writeBinaryFile;
-    }
-  },
-  renameFile: () => {
-    {
-      return renameFile;
-    }
-  },
-  removeFile: () => {
-    {
-      return removeFile;
-    }
-  },
-  removeDir: () => {
-    {
-      return removeDir;
-    }
-  },
-  readTextFile: () => {
-    {
-      return readTextFile;
-    }
-  },
-  readDir: () => {
-    {
-      return readDir;
-    }
-  },
-  readBinaryFile: () => {
-    {
-      return readBinaryFile;
-    }
-  },
-  exists: () => {
-    {
-      return exists;
-    }
-  },
-  createDir: () => {
-    {
-      return createDir;
-    }
-  },
-  copyFile: () => {
-    {
-      return copyFile;
-    }
-  },
-  Dir: () => {
-    {
-      return BaseDirectory;
-    }
-  },
-  BaseDirectory: () => {
-    {
-      return BaseDirectory;
-    }
-  }
-});
-async function readTextFile(filePath, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "readTextFile",
-      path: filePath,
-      options
-    }
-  });
-}
-async function readBinaryFile(filePath, options = {}) {
-  const arr = await invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "readFile",
-      path: filePath,
-      options
-    }
-  });
-  return Uint8Array.from(arr);
-}
-async function writeTextFile(path, contents, options) {
-  if (typeof options === "object") {
-    Object.freeze(options);
-  }
-  if (typeof path === "object") {
-    Object.freeze(path);
-  }
-  const file = { path: "", contents: "" };
-  let fileOptions = options;
-  if (typeof path === "string") {
-    file.path = path;
-  } else {
-    file.path = path.path;
-    file.contents = path.contents;
-  }
-  if (typeof contents === "string") {
-    file.contents = contents ?? "";
-  } else {
-    fileOptions = contents;
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "writeFile",
-      path: file.path,
-      contents: Array.from(new TextEncoder().encode(file.contents)),
-      options: fileOptions
-    }
-  });
-}
-async function writeBinaryFile(path, contents, options) {
-  if (typeof options === "object") {
-    Object.freeze(options);
-  }
-  if (typeof path === "object") {
-    Object.freeze(path);
-  }
-  const file = { path: "", contents: [] };
-  let fileOptions = options;
-  if (typeof path === "string") {
-    file.path = path;
-  } else {
-    file.path = path.path;
-    file.contents = path.contents;
-  }
-  if (contents && "dir" in contents) {
-    fileOptions = contents;
-  } else if (typeof path === "string") {
-    file.contents = contents ?? [];
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "writeFile",
-      path: file.path,
-      contents: Array.from(file.contents instanceof ArrayBuffer ? new Uint8Array(file.contents) : file.contents),
-      options: fileOptions
-    }
-  });
-}
-async function readDir(dir, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "readDir",
-      path: dir,
-      options
-    }
-  });
-}
-async function createDir(dir, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "createDir",
-      path: dir,
-      options
-    }
-  });
-}
-async function removeDir(dir, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "removeDir",
-      path: dir,
-      options
-    }
-  });
-}
-async function copyFile(source, destination, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "copyFile",
-      source,
-      destination,
-      options
-    }
-  });
-}
-async function removeFile(file, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "removeFile",
-      path: file,
-      options
-    }
-  });
-}
-async function renameFile(oldPath, newPath, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "renameFile",
-      oldPath,
-      newPath,
-      options
-    }
-  });
-}
-async function exists(path, options = {}) {
-  return invokeTauriCommand({
-    __tauriModule: "Fs",
-    message: {
-      cmd: "exists",
-      path,
-      options
-    }
-  });
-}
-var BaseDirectory;
-(function(BaseDirectory2) {
-  BaseDirectory2[BaseDirectory2["Audio"] = 1] = "Audio";
-  BaseDirectory2[BaseDirectory2["Cache"] = 2] = "Cache";
-  BaseDirectory2[BaseDirectory2["Config"] = 3] = "Config";
-  BaseDirectory2[BaseDirectory2["Data"] = 4] = "Data";
-  BaseDirectory2[BaseDirectory2["LocalData"] = 5] = "LocalData";
-  BaseDirectory2[BaseDirectory2["Desktop"] = 6] = "Desktop";
-  BaseDirectory2[BaseDirectory2["Document"] = 7] = "Document";
-  BaseDirectory2[BaseDirectory2["Download"] = 8] = "Download";
-  BaseDirectory2[BaseDirectory2["Executable"] = 9] = "Executable";
-  BaseDirectory2[BaseDirectory2["Font"] = 10] = "Font";
-  BaseDirectory2[BaseDirectory2["Home"] = 11] = "Home";
-  BaseDirectory2[BaseDirectory2["Picture"] = 12] = "Picture";
-  BaseDirectory2[BaseDirectory2["Public"] = 13] = "Public";
-  BaseDirectory2[BaseDirectory2["Runtime"] = 14] = "Runtime";
-  BaseDirectory2[BaseDirectory2["Template"] = 15] = "Template";
-  BaseDirectory2[BaseDirectory2["Video"] = 16] = "Video";
-  BaseDirectory2[BaseDirectory2["Resource"] = 17] = "Resource";
-  BaseDirectory2[BaseDirectory2["App"] = 18] = "App";
-  BaseDirectory2[BaseDirectory2["Log"] = 19] = "Log";
-  BaseDirectory2[BaseDirectory2["Temp"] = 20] = "Temp";
-  BaseDirectory2[BaseDirectory2["AppConfig"] = 21] = "AppConfig";
-  BaseDirectory2[BaseDirectory2["AppData"] = 22] = "AppData";
-  BaseDirectory2[BaseDirectory2["AppLocalData"] = 23] = "AppLocalData";
-  BaseDirectory2[BaseDirectory2["AppCache"] = 24] = "AppCache";
-  BaseDirectory2[BaseDirectory2["AppLog"] = 25] = "AppLog";
-})(BaseDirectory || (BaseDirectory = {}));
-
-// ../../../../node_modules/@tauri-apps/api/globalShortcut.js
-var exports_globalShortcut = {};
-__export(exports_globalShortcut, {
-  unregisterAll: () => {
-    {
-      return unregisterAll;
-    }
-  },
-  unregister: () => {
-    {
-      return unregister;
-    }
-  },
-  registerAll: () => {
-    {
-      return registerAll;
-    }
-  },
-  register: () => {
-    {
-      return register;
-    }
-  },
-  isRegistered: () => {
-    {
-      return isRegistered;
-    }
-  }
-});
-async function register(shortcut, handler) {
-  return invokeTauriCommand({
-    __tauriModule: "GlobalShortcut",
-    message: {
-      cmd: "register",
-      shortcut,
-      handler: transformCallback(handler)
-    }
-  });
-}
-async function registerAll(shortcuts, handler) {
-  return invokeTauriCommand({
-    __tauriModule: "GlobalShortcut",
-    message: {
-      cmd: "registerAll",
-      shortcuts,
-      handler: transformCallback(handler)
-    }
-  });
-}
-async function isRegistered(shortcut) {
-  return invokeTauriCommand({
-    __tauriModule: "GlobalShortcut",
-    message: {
-      cmd: "isRegistered",
-      shortcut
-    }
-  });
-}
-async function unregister(shortcut) {
-  return invokeTauriCommand({
-    __tauriModule: "GlobalShortcut",
-    message: {
-      cmd: "unregister",
-      shortcut
-    }
-  });
-}
-async function unregisterAll() {
-  return invokeTauriCommand({
-    __tauriModule: "GlobalShortcut",
-    message: {
-      cmd: "unregisterAll"
-    }
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/http.js
-var exports_http = {};
-__export(exports_http, {
-  getClient: () => {
-    {
-      return getClient;
-    }
-  },
-  fetch: () => {
-    {
-      return fetch;
-    }
-  },
-  ResponseType: () => {
-    {
-      return ResponseType;
-    }
-  },
-  Response: () => {
-    {
-      return Response;
-    }
-  },
-  Client: () => {
-    {
-      return Client;
-    }
-  },
-  Body: () => {
-    {
-      return Body;
-    }
-  }
-});
-async function formBody(data) {
-  const form = {};
-  const append = async (key, v) => {
-    if (v !== null) {
-      let r;
-      if (typeof v === "string") {
-        r = v;
-      } else if (v instanceof Uint8Array || Array.isArray(v)) {
-        r = Array.from(v);
-      } else if (v instanceof File) {
-        r = {
-          file: Array.from(new Uint8Array(await v.arrayBuffer())),
-          mime: v.type,
-          fileName: v.name
-        };
-      } else if (typeof v.file === "string") {
-        r = { file: v.file, mime: v.mime, fileName: v.fileName };
-      } else {
-        r = { file: Array.from(v.file), mime: v.mime, fileName: v.fileName };
-      }
-      form[String(key)] = r;
-    }
-  };
-  if (data instanceof FormData) {
-    for (const [key, value] of data) {
-      await append(key, value);
-    }
-  } else {
-    for (const [key, value] of Object.entries(data)) {
-      await append(key, value);
-    }
-  }
-  return form;
-}
-async function getClient(options) {
-  return invokeTauriCommand({
-    __tauriModule: "Http",
-    message: {
-      cmd: "createClient",
-      options
-    }
-  }).then((id) => new Client(id));
-}
-async function fetch(url, options) {
-  if (defaultClient === null) {
-    defaultClient = await getClient();
-  }
-  return defaultClient.request({
-    url,
-    method: options?.method ?? "GET",
-    ...options
-  });
-}
-var ResponseType;
-(function(ResponseType2) {
-  ResponseType2[ResponseType2["JSON"] = 1] = "JSON";
-  ResponseType2[ResponseType2["Text"] = 2] = "Text";
-  ResponseType2[ResponseType2["Binary"] = 3] = "Binary";
-})(ResponseType || (ResponseType = {}));
-
-class Body {
-  constructor(type, payload) {
-    this.type = type;
-    this.payload = payload;
-  }
-  static form(data) {
-    return new Body("Form", data);
-  }
-  static json(data) {
-    return new Body("Json", data);
-  }
-  static text(value) {
-    return new Body("Text", value);
-  }
-  static bytes(bytes) {
-    return new Body("Bytes", Array.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes));
-  }
-}
-
-class Response {
-  constructor(response) {
-    this.url = response.url;
-    this.status = response.status;
-    this.ok = this.status >= 200 && this.status < 300;
-    this.headers = response.headers;
-    this.rawHeaders = response.rawHeaders;
-    this.data = response.data;
-  }
-}
-
-class Client {
-  constructor(id) {
-    this.id = id;
-  }
-  async drop() {
-    return invokeTauriCommand({
-      __tauriModule: "Http",
-      message: {
-        cmd: "dropClient",
-        client: this.id
-      }
-    });
-  }
-  async request(options) {
-    const jsonResponse = !options.responseType || options.responseType === ResponseType.JSON;
-    if (jsonResponse) {
-      options.responseType = ResponseType.Text;
-    }
-    if (options.body?.type === "Form") {
-      options.body.payload = await formBody(options.body.payload);
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Http",
-      message: {
-        cmd: "httpRequest",
-        client: this.id,
-        options
-      }
-    }).then((res) => {
-      const response = new Response(res);
-      if (jsonResponse) {
-        try {
-          response.data = JSON.parse(response.data);
-        } catch (e) {
-          if (response.ok && response.data === "") {
-            response.data = {};
-          } else if (response.ok) {
-            throw Error(`Failed to parse response \`${response.data}\` as JSON: ${e};
-              try setting the \`responseType\` option to \`ResponseType.Text\` or \`ResponseType.Binary\` if the API does not return a JSON response.`);
-          }
-        }
-        return response;
-      }
-      return response;
-    });
-  }
-  async get(url, options) {
-    return this.request({
-      method: "GET",
-      url,
-      ...options
-    });
-  }
-  async post(url, body, options) {
-    return this.request({
-      method: "POST",
-      url,
-      body,
-      ...options
-    });
-  }
-  async put(url, body, options) {
-    return this.request({
-      method: "PUT",
-      url,
-      body,
-      ...options
-    });
-  }
-  async patch(url, options) {
-    return this.request({
-      method: "PATCH",
-      url,
-      ...options
-    });
-  }
-  async delete(url, options) {
-    return this.request({
-      method: "DELETE",
-      url,
-      ...options
-    });
-  }
-}
-var defaultClient = null;
-
-// ../../../../node_modules/@tauri-apps/api/mocks.js
-var exports_mocks = {};
-__export(exports_mocks, {
-  mockWindows: () => {
-    {
-      return mockWindows;
-    }
-  },
-  mockIPC: () => {
-    {
-      return mockIPC;
-    }
-  },
-  mockConvertFileSrc: () => {
-    {
-      return mockConvertFileSrc;
-    }
-  },
-  clearMocks: () => {
-    {
-      return clearMocks;
-    }
-  }
-});
-var mockIPC = function(cb) {
-  window.__TAURI_IPC__ = async ({ cmd, callback, error, ...args }) => {
-    try {
-      window[`_${callback}`](await cb(cmd, args));
-    } catch (err) {
-      window[`_${error}`](err);
-    }
-  };
-};
-var mockWindows = function(current, ...additionalWindows) {
-  window.__TAURI_METADATA__ = {
-    __windows: [current, ...additionalWindows].map((label) => ({ label })),
-    __currentWindow: { label: current }
-  };
-};
-var mockConvertFileSrc = function(osName, windowsProtocolScheme = "https") {
-  window.__TAURI__ = window.__TAURI__ ?? {};
-  window.__TAURI__.convertFileSrc = function(filePath, protocol = "asset") {
-    const path = encodeURIComponent(filePath);
-    return osName === "windows" ? `${windowsProtocolScheme}://${protocol}.localhost/${path}` : `${protocol}://localhost/${path}`;
-  };
-};
-var clearMocks = function() {
-  if (window.__TAURI__?.convertFileSrc)
-    delete window.__TAURI__.convertFileSrc;
-  if (window.__TAURI_IPC__)
-    delete window.__TAURI_IPC__;
-  if (window.__TAURI_METADATA__)
-    delete window.__TAURI_METADATA__;
-};
-
-// ../../../../node_modules/@tauri-apps/api/notification.js
-var exports_notification = {};
-__export(exports_notification, {
-  sendNotification: () => {
-    {
-      return sendNotification;
-    }
-  },
-  requestPermission: () => {
-    {
-      return requestPermission;
-    }
-  },
-  isPermissionGranted: () => {
-    {
-      return isPermissionGranted;
-    }
-  }
-});
-async function isPermissionGranted() {
-  if (window.Notification.permission !== "default") {
-    return Promise.resolve(window.Notification.permission === "granted");
-  }
-  return invokeTauriCommand({
-    __tauriModule: "Notification",
-    message: {
-      cmd: "isNotificationPermissionGranted"
-    }
-  });
-}
-async function requestPermission() {
-  return window.Notification.requestPermission();
-}
-var sendNotification = function(options) {
-  if (typeof options === "string") {
-    new window.Notification(options);
-  } else {
-    new window.Notification(options.title, options);
-  }
-};
-
-// ../../../../node_modules/@tauri-apps/api/os.js
-var exports_os = {};
-__export(exports_os, {
-  version: () => {
-    {
-      return version;
-    }
-  },
-  type: () => {
-    {
-      return type;
-    }
-  },
-  tempdir: () => {
-    {
-      return tempdir;
-    }
-  },
-  platform: () => {
-    {
-      return platform;
-    }
-  },
-  locale: () => {
-    {
-      return locale;
-    }
-  },
-  arch: () => {
-    {
-      return arch;
-    }
-  },
-  EOL: () => {
-    {
-      return EOL;
-    }
-  }
-});
-
-// ../../../../node_modules/@tauri-apps/api/helpers/os-check.js
-var isWindows = function() {
-  return navigator.appVersion.includes("Win");
-};
-
-// ../../../../node_modules/@tauri-apps/api/os.js
-async function platform() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "platform"
-    }
-  });
-}
-async function version() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "version"
-    }
-  });
-}
-async function type() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "osType"
-    }
-  });
-}
-async function arch() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "arch"
-    }
-  });
-}
-async function tempdir() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "tempdir"
-    }
-  });
-}
-async function locale() {
-  return invokeTauriCommand({
-    __tauriModule: "Os",
-    message: {
-      cmd: "locale"
-    }
-  });
-}
-var EOL = isWindows() ? "\r\n" : "\n";
-
-// ../../../../node_modules/@tauri-apps/api/path.js
-var exports_path = {};
-__export(exports_path, {
-  videoDir: () => {
-    {
-      return videoDir;
-    }
-  },
-  templateDir: () => {
-    {
-      return templateDir;
-    }
-  },
-  sep: () => {
-    {
-      return sep;
-    }
-  },
-  runtimeDir: () => {
-    {
-      return runtimeDir;
-    }
-  },
-  resourceDir: () => {
-    {
-      return resourceDir;
-    }
-  },
-  resolveResource: () => {
-    {
-      return resolveResource;
-    }
-  },
-  resolve: () => {
-    {
-      return resolve;
-    }
-  },
-  publicDir: () => {
-    {
-      return publicDir;
-    }
-  },
-  pictureDir: () => {
-    {
-      return pictureDir;
-    }
-  },
-  normalize: () => {
-    {
-      return normalize;
-    }
-  },
-  logDir: () => {
-    {
-      return logDir;
-    }
-  },
-  localDataDir: () => {
-    {
-      return localDataDir;
-    }
-  },
-  join: () => {
-    {
-      return join;
-    }
-  },
-  isAbsolute: () => {
-    {
-      return isAbsolute;
-    }
-  },
-  homeDir: () => {
-    {
-      return homeDir;
-    }
-  },
-  fontDir: () => {
-    {
-      return fontDir;
-    }
-  },
-  extname: () => {
-    {
-      return extname;
-    }
-  },
-  executableDir: () => {
-    {
-      return executableDir;
-    }
-  },
-  downloadDir: () => {
-    {
-      return downloadDir;
-    }
-  },
-  documentDir: () => {
-    {
-      return documentDir;
-    }
-  },
-  dirname: () => {
-    {
-      return dirname;
-    }
-  },
-  desktopDir: () => {
-    {
-      return desktopDir;
-    }
-  },
-  delimiter: () => {
-    {
-      return delimiter;
-    }
-  },
-  dataDir: () => {
-    {
-      return dataDir;
-    }
-  },
-  configDir: () => {
-    {
-      return configDir;
-    }
-  },
-  cacheDir: () => {
-    {
-      return cacheDir;
-    }
-  },
-  basename: () => {
-    {
-      return basename;
-    }
-  },
-  audioDir: () => {
-    {
-      return audioDir;
-    }
-  },
-  appLogDir: () => {
-    {
-      return appLogDir;
-    }
-  },
-  appLocalDataDir: () => {
-    {
-      return appLocalDataDir;
-    }
-  },
-  appDir: () => {
-    {
-      return appDir;
-    }
-  },
-  appDataDir: () => {
-    {
-      return appDataDir;
-    }
-  },
-  appConfigDir: () => {
-    {
-      return appConfigDir;
-    }
-  },
-  appCacheDir: () => {
-    {
-      return appCacheDir;
-    }
-  },
-  BaseDirectory: () => {
-    {
-      return BaseDirectory;
-    }
-  }
-});
-async function appDir() {
-  return appConfigDir();
-}
-async function appConfigDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.AppConfig
-    }
-  });
-}
-async function appDataDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.AppData
-    }
-  });
-}
-async function appLocalDataDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.AppLocalData
-    }
-  });
-}
-async function appCacheDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.AppCache
-    }
-  });
-}
-async function audioDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Audio
-    }
-  });
-}
-async function cacheDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Cache
-    }
-  });
-}
-async function configDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Config
-    }
-  });
-}
-async function dataDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Data
-    }
-  });
-}
-async function desktopDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Desktop
-    }
-  });
-}
-async function documentDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Document
-    }
-  });
-}
-async function downloadDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Download
-    }
-  });
-}
-async function executableDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Executable
-    }
-  });
-}
-async function fontDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Font
-    }
-  });
-}
-async function homeDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Home
-    }
-  });
-}
-async function localDataDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.LocalData
-    }
-  });
-}
-async function pictureDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Picture
-    }
-  });
-}
-async function publicDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Public
-    }
-  });
-}
-async function resourceDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Resource
-    }
-  });
-}
-async function resolveResource(resourcePath) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: resourcePath,
-      directory: BaseDirectory.Resource
-    }
-  });
-}
-async function runtimeDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Runtime
-    }
-  });
-}
-async function templateDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Template
-    }
-  });
-}
-async function videoDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.Video
-    }
-  });
-}
-async function logDir() {
-  return appLogDir();
-}
-async function appLogDir() {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolvePath",
-      path: "",
-      directory: BaseDirectory.AppLog
-    }
-  });
-}
-async function resolve(...paths) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "resolve",
-      paths
-    }
-  });
-}
-async function normalize(path) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "normalize",
-      path
-    }
-  });
-}
-async function join(...paths) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "join",
-      paths
-    }
-  });
-}
-async function dirname(path) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "dirname",
-      path
-    }
-  });
-}
-async function extname(path) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "extname",
-      path
-    }
-  });
-}
-async function basename(path, ext) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "basename",
-      path,
-      ext
-    }
-  });
-}
-async function isAbsolute(path) {
-  return invokeTauriCommand({
-    __tauriModule: "Path",
-    message: {
-      cmd: "isAbsolute",
-      path
-    }
-  });
-}
-var sep = isWindows() ? "\\" : "/";
-var delimiter = isWindows() ? ";" : ":";
-
-// ../../../../node_modules/@tauri-apps/api/process.js
-var exports_process = {};
-__export(exports_process, {
-  relaunch: () => {
-    {
-      return relaunch;
-    }
-  },
-  exit: () => {
-    {
-      return exit;
-    }
-  }
-});
-async function exit(exitCode = 0) {
-  return invokeTauriCommand({
-    __tauriModule: "Process",
-    message: {
-      cmd: "exit",
-      exitCode
-    }
-  });
-}
-async function relaunch() {
-  return invokeTauriCommand({
-    __tauriModule: "Process",
-    message: {
-      cmd: "relaunch"
-    }
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/updater.js
-var exports_updater = {};
-__export(exports_updater, {
-  onUpdaterEvent: () => {
-    {
-      return onUpdaterEvent;
-    }
-  },
-  installUpdate: () => {
-    {
-      return installUpdate;
-    }
-  },
-  checkUpdate: () => {
-    {
-      return checkUpdate;
-    }
-  }
-});
-async function onUpdaterEvent(handler) {
-  return listen2(TauriEvent.STATUS_UPDATE, (data) => {
-    handler(data?.payload);
-  });
-}
-async function installUpdate() {
-  let unlistenerFn;
-  function cleanListener() {
-    if (unlistenerFn) {
-      unlistenerFn();
-    }
-    unlistenerFn = undefined;
-  }
-  return new Promise((resolve2, reject) => {
-    function onStatusChange(statusResult) {
-      if (statusResult.error) {
-        cleanListener();
-        reject(statusResult.error);
-        return;
-      }
-      if (statusResult.status === "DONE") {
-        cleanListener();
-        resolve2();
-      }
-    }
-    onUpdaterEvent(onStatusChange).then((fn) => {
-      unlistenerFn = fn;
-    }).catch((e) => {
-      cleanListener();
-      throw e;
-    });
-    emit2(TauriEvent.INSTALL_UPDATE).catch((e) => {
-      cleanListener();
-      throw e;
-    });
-  });
-}
-async function checkUpdate() {
-  let unlistenerFn;
-  function cleanListener() {
-    if (unlistenerFn) {
-      unlistenerFn();
-    }
-    unlistenerFn = undefined;
-  }
-  return new Promise((resolve2, reject) => {
-    function onUpdateAvailable(manifest) {
-      cleanListener();
-      resolve2({
-        manifest,
-        shouldUpdate: true
-      });
-    }
-    function onStatusChange(statusResult) {
-      if (statusResult.error) {
-        cleanListener();
-        reject(statusResult.error);
-        return;
-      }
-      if (statusResult.status === "UPTODATE") {
-        cleanListener();
-        resolve2({
-          shouldUpdate: false
-        });
-      }
-    }
-    once2(TauriEvent.UPDATE_AVAILABLE, (data) => {
-      onUpdateAvailable(data?.payload);
-    }).catch((e) => {
-      cleanListener();
-      throw e;
-    });
-    onUpdaterEvent(onStatusChange).then((fn) => {
-      unlistenerFn = fn;
-    }).catch((e) => {
-      cleanListener();
-      throw e;
-    });
-    emit2(TauriEvent.CHECK_UPDATE).catch((e) => {
-      cleanListener();
-      throw e;
-    });
-  });
-}
-
-// ../../../../node_modules/@tauri-apps/api/window.js
-var exports_window = {};
-__export(exports_window, {
-  primaryMonitor: () => {
-    {
-      return primaryMonitor;
-    }
-  },
-  getCurrent: () => {
-    {
-      return getCurrent;
-    }
-  },
-  getAll: () => {
-    {
-      return getAll;
-    }
-  },
-  currentMonitor: () => {
-    {
-      return currentMonitor;
-    }
-  },
-  availableMonitors: () => {
-    {
-      return availableMonitors;
-    }
-  },
-  appWindow: () => {
-    {
-      return appWindow;
-    }
-  },
-  WindowManager: () => {
-    {
-      return WindowManager;
-    }
-  },
-  WebviewWindowHandle: () => {
-    {
-      return WebviewWindowHandle;
-    }
-  },
-  WebviewWindow: () => {
-    {
-      return WebviewWindow;
-    }
-  },
-  UserAttentionType: () => {
-    {
-      return UserAttentionType;
-    }
-  },
-  PhysicalSize: () => {
-    {
-      return PhysicalSize;
-    }
-  },
-  PhysicalPosition: () => {
-    {
-      return PhysicalPosition;
-    }
-  },
-  LogicalSize: () => {
-    {
-      return LogicalSize;
-    }
-  },
-  LogicalPosition: () => {
-    {
-      return LogicalPosition;
-    }
-  },
-  CloseRequestedEvent: () => {
-    {
-      return CloseRequestedEvent;
-    }
-  }
-});
-var getCurrent = function() {
-  return new WebviewWindow(window.__TAURI_METADATA__.__currentWindow.label, {
-    skip: true
-  });
-};
-var getAll = function() {
-  return window.__TAURI_METADATA__.__windows.map((w) => new WebviewWindow(w.label, {
-    skip: true
-  }));
-};
-var mapMonitor = function(m) {
-  return m === null ? null : {
-    name: m.name,
-    scaleFactor: m.scaleFactor,
-    position: mapPhysicalPosition(m.position),
-    size: mapPhysicalSize(m.size)
-  };
-};
-var mapPhysicalPosition = function(m) {
-  return new PhysicalPosition(m.x, m.y);
-};
-var mapPhysicalSize = function(m) {
-  return new PhysicalSize(m.width, m.height);
-};
-async function currentMonitor() {
-  return invokeTauriCommand({
-    __tauriModule: "Window",
-    message: {
-      cmd: "manage",
-      data: {
-        cmd: {
-          type: "currentMonitor"
-        }
-      }
-    }
-  }).then(mapMonitor);
-}
-async function primaryMonitor() {
-  return invokeTauriCommand({
-    __tauriModule: "Window",
-    message: {
-      cmd: "manage",
-      data: {
-        cmd: {
-          type: "primaryMonitor"
-        }
-      }
-    }
-  }).then(mapMonitor);
-}
-async function availableMonitors() {
-  return invokeTauriCommand({
-    __tauriModule: "Window",
-    message: {
-      cmd: "manage",
-      data: {
-        cmd: {
-          type: "availableMonitors"
-        }
-      }
-    }
-  }).then((ms) => ms.map(mapMonitor));
-}
-
-class LogicalSize {
-  constructor(width, height) {
-    this.type = "Logical";
-    this.width = width;
-    this.height = height;
-  }
-}
-
-class PhysicalSize {
-  constructor(width, height) {
-    this.type = "Physical";
-    this.width = width;
-    this.height = height;
-  }
-  toLogical(scaleFactor) {
-    return new LogicalSize(this.width / scaleFactor, this.height / scaleFactor);
-  }
-}
-
-class LogicalPosition {
-  constructor(x, y) {
-    this.type = "Logical";
-    this.x = x;
-    this.y = y;
-  }
-}
-
-class PhysicalPosition {
-  constructor(x, y) {
-    this.type = "Physical";
-    this.x = x;
-    this.y = y;
-  }
-  toLogical(scaleFactor) {
-    return new LogicalPosition(this.x / scaleFactor, this.y / scaleFactor);
-  }
-}
-var UserAttentionType;
-(function(UserAttentionType2) {
-  UserAttentionType2[UserAttentionType2["Critical"] = 1] = "Critical";
-  UserAttentionType2[UserAttentionType2["Informational"] = 2] = "Informational";
-})(UserAttentionType || (UserAttentionType = {}));
-var localTauriEvents = ["tauri://created", "tauri://error"];
-
-class WebviewWindowHandle {
-  constructor(label) {
-    this.label = label;
-    this.listeners = Object.create(null);
-  }
-  async listen(event5, handler) {
-    if (this._handleTauriEvent(event5, handler)) {
-      return Promise.resolve(() => {
-        const listeners = this.listeners[event5];
-        listeners.splice(listeners.indexOf(handler), 1);
-      });
-    }
-    return listen(event5, this.label, handler);
-  }
-  async once(event5, handler) {
-    if (this._handleTauriEvent(event5, handler)) {
-      return Promise.resolve(() => {
-        const listeners = this.listeners[event5];
-        listeners.splice(listeners.indexOf(handler), 1);
-      });
-    }
-    return once(event5, this.label, handler);
-  }
-  async emit(event5, payload) {
-    if (localTauriEvents.includes(event5)) {
-      for (const handler of this.listeners[event5] || []) {
-        handler({ event: event5, id: -1, windowLabel: this.label, payload });
-      }
-      return Promise.resolve();
-    }
-    return emit(event5, this.label, payload);
-  }
-  _handleTauriEvent(event5, handler) {
-    if (localTauriEvents.includes(event5)) {
-      if (!(event5 in this.listeners)) {
-        this.listeners[event5] = [handler];
-      } else {
-        this.listeners[event5].push(handler);
-      }
-      return true;
-    }
-    return false;
-  }
-}
-
-class WindowManager extends WebviewWindowHandle {
-  async scaleFactor() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "scaleFactor"
-          }
-        }
-      }
-    });
-  }
-  async innerPosition() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "innerPosition"
-          }
-        }
-      }
-    }).then(({ x, y }) => new PhysicalPosition(x, y));
-  }
-  async outerPosition() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "outerPosition"
-          }
-        }
-      }
-    }).then(({ x, y }) => new PhysicalPosition(x, y));
-  }
-  async innerSize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "innerSize"
-          }
-        }
-      }
-    }).then(({ width, height }) => new PhysicalSize(width, height));
-  }
-  async outerSize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "outerSize"
-          }
-        }
-      }
-    }).then(({ width, height }) => new PhysicalSize(width, height));
-  }
-  async isFullscreen() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isFullscreen"
-          }
-        }
-      }
-    });
-  }
-  async isMinimized() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isMinimized"
-          }
-        }
-      }
-    });
-  }
-  async isMaximized() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isMaximized"
-          }
-        }
-      }
-    });
-  }
-  async isFocused() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isFocused"
-          }
-        }
-      }
-    });
-  }
-  async isDecorated() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isDecorated"
-          }
-        }
-      }
-    });
-  }
-  async isResizable() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isResizable"
-          }
-        }
-      }
-    });
-  }
-  async isMaximizable() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isMaximizable"
-          }
-        }
-      }
-    });
-  }
-  async isMinimizable() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isMinimizable"
-          }
-        }
-      }
-    });
-  }
-  async isClosable() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isClosable"
-          }
-        }
-      }
-    });
-  }
-  async isVisible() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "isVisible"
-          }
-        }
-      }
-    });
-  }
-  async title() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "title"
-          }
-        }
-      }
-    });
-  }
-  async theme() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "theme"
-          }
-        }
-      }
-    });
-  }
-  async center() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "center"
-          }
-        }
-      }
-    });
-  }
-  async requestUserAttention(requestType) {
-    let requestType_ = null;
-    if (requestType) {
-      if (requestType === UserAttentionType.Critical) {
-        requestType_ = { type: "Critical" };
-      } else {
-        requestType_ = { type: "Informational" };
-      }
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "requestUserAttention",
-            payload: requestType_
-          }
-        }
-      }
-    });
-  }
-  async setResizable(resizable) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setResizable",
-            payload: resizable
-          }
-        }
-      }
-    });
-  }
-  async setMaximizable(maximizable) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setMaximizable",
-            payload: maximizable
-          }
-        }
-      }
-    });
-  }
-  async setMinimizable(minimizable) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setMinimizable",
-            payload: minimizable
-          }
-        }
-      }
-    });
-  }
-  async setClosable(closable) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setClosable",
-            payload: closable
-          }
-        }
-      }
-    });
-  }
-  async setTitle(title) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setTitle",
-            payload: title
-          }
-        }
-      }
-    });
-  }
-  async maximize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "maximize"
-          }
-        }
-      }
-    });
-  }
-  async unmaximize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "unmaximize"
-          }
-        }
-      }
-    });
-  }
-  async toggleMaximize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "toggleMaximize"
-          }
-        }
-      }
-    });
-  }
-  async minimize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "minimize"
-          }
-        }
-      }
-    });
-  }
-  async unminimize() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "unminimize"
-          }
-        }
-      }
-    });
-  }
-  async show() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "show"
-          }
-        }
-      }
-    });
-  }
-  async hide() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "hide"
-          }
-        }
-      }
-    });
-  }
-  async close() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "close"
-          }
-        }
-      }
-    });
-  }
-  async setDecorations(decorations) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setDecorations",
-            payload: decorations
-          }
-        }
-      }
-    });
-  }
-  async setAlwaysOnTop(alwaysOnTop) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setAlwaysOnTop",
-            payload: alwaysOnTop
-          }
-        }
-      }
-    });
-  }
-  async setContentProtected(protected_) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setContentProtected",
-            payload: protected_
-          }
-        }
-      }
-    });
-  }
-  async setSize(size) {
-    if (!size || size.type !== "Logical" && size.type !== "Physical") {
-      throw new Error("the `size` argument must be either a LogicalSize or a PhysicalSize instance");
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setSize",
-            payload: {
-              type: size.type,
-              data: {
-                width: size.width,
-                height: size.height
-              }
-            }
-          }
-        }
-      }
-    });
-  }
-  async setMinSize(size) {
-    if (size && size.type !== "Logical" && size.type !== "Physical") {
-      throw new Error("the `size` argument must be either a LogicalSize or a PhysicalSize instance");
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setMinSize",
-            payload: size ? {
-              type: size.type,
-              data: {
-                width: size.width,
-                height: size.height
-              }
-            } : null
-          }
-        }
-      }
-    });
-  }
-  async setMaxSize(size) {
-    if (size && size.type !== "Logical" && size.type !== "Physical") {
-      throw new Error("the `size` argument must be either a LogicalSize or a PhysicalSize instance");
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setMaxSize",
-            payload: size ? {
-              type: size.type,
-              data: {
-                width: size.width,
-                height: size.height
-              }
-            } : null
-          }
-        }
-      }
-    });
-  }
-  async setPosition(position) {
-    if (!position || position.type !== "Logical" && position.type !== "Physical") {
-      throw new Error("the `position` argument must be either a LogicalPosition or a PhysicalPosition instance");
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setPosition",
-            payload: {
-              type: position.type,
-              data: {
-                x: position.x,
-                y: position.y
-              }
-            }
-          }
-        }
-      }
-    });
-  }
-  async setFullscreen(fullscreen) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setFullscreen",
-            payload: fullscreen
-          }
-        }
-      }
-    });
-  }
-  async setFocus() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setFocus"
-          }
-        }
-      }
-    });
-  }
-  async setIcon(icon) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setIcon",
-            payload: {
-              icon: typeof icon === "string" ? icon : Array.from(icon)
-            }
-          }
-        }
-      }
-    });
-  }
-  async setSkipTaskbar(skip) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setSkipTaskbar",
-            payload: skip
-          }
-        }
-      }
-    });
-  }
-  async setCursorGrab(grab) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setCursorGrab",
-            payload: grab
-          }
-        }
-      }
-    });
-  }
-  async setCursorVisible(visible) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setCursorVisible",
-            payload: visible
-          }
-        }
-      }
-    });
-  }
-  async setCursorIcon(icon) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setCursorIcon",
-            payload: icon
-          }
-        }
-      }
-    });
-  }
-  async setCursorPosition(position) {
-    if (!position || position.type !== "Logical" && position.type !== "Physical") {
-      throw new Error("the `position` argument must be either a LogicalPosition or a PhysicalPosition instance");
-    }
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setCursorPosition",
-            payload: {
-              type: position.type,
-              data: {
-                x: position.x,
-                y: position.y
-              }
-            }
-          }
-        }
-      }
-    });
-  }
-  async setIgnoreCursorEvents(ignore) {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "setIgnoreCursorEvents",
-            payload: ignore
-          }
-        }
-      }
-    });
-  }
-  async startDragging() {
-    return invokeTauriCommand({
-      __tauriModule: "Window",
-      message: {
-        cmd: "manage",
-        data: {
-          label: this.label,
-          cmd: {
-            type: "startDragging"
-          }
-        }
-      }
-    });
-  }
-  async onResized(handler) {
-    return this.listen(TauriEvent.WINDOW_RESIZED, (e) => {
-      e.payload = mapPhysicalSize(e.payload);
-      handler(e);
-    });
-  }
-  async onMoved(handler) {
-    return this.listen(TauriEvent.WINDOW_MOVED, (e) => {
-      e.payload = mapPhysicalPosition(e.payload);
-      handler(e);
-    });
-  }
-  async onCloseRequested(handler) {
-    return this.listen(TauriEvent.WINDOW_CLOSE_REQUESTED, (event5) => {
-      const evt = new CloseRequestedEvent(event5);
-      Promise.resolve(handler(evt)).then(() => {
-        if (!evt.isPreventDefault()) {
-          return this.close();
-        }
-      });
-    });
-  }
-  async onFocusChanged(handler) {
-    const unlistenFocus = await this.listen(TauriEvent.WINDOW_FOCUS, (event5) => {
-      handler({ ...event5, payload: true });
-    });
-    const unlistenBlur = await this.listen(TauriEvent.WINDOW_BLUR, (event5) => {
-      handler({ ...event5, payload: false });
-    });
-    return () => {
-      unlistenFocus();
-      unlistenBlur();
-    };
-  }
-  async onScaleChanged(handler) {
-    return this.listen(TauriEvent.WINDOW_SCALE_FACTOR_CHANGED, handler);
-  }
-  async onMenuClicked(handler) {
-    return this.listen(TauriEvent.MENU, handler);
-  }
-  async onFileDropEvent(handler) {
-    const unlistenFileDrop = await this.listen(TauriEvent.WINDOW_FILE_DROP, (event5) => {
-      handler({ ...event5, payload: { type: "drop", paths: event5.payload } });
-    });
-    const unlistenFileHover = await this.listen(TauriEvent.WINDOW_FILE_DROP_HOVER, (event5) => {
-      handler({ ...event5, payload: { type: "hover", paths: event5.payload } });
-    });
-    const unlistenCancel = await this.listen(TauriEvent.WINDOW_FILE_DROP_CANCELLED, (event5) => {
-      handler({ ...event5, payload: { type: "cancel" } });
-    });
-    return () => {
-      unlistenFileDrop();
-      unlistenFileHover();
-      unlistenCancel();
-    };
-  }
-  async onThemeChanged(handler) {
-    return this.listen(TauriEvent.WINDOW_THEME_CHANGED, handler);
-  }
-}
-
-class CloseRequestedEvent {
-  constructor(event5) {
-    this._preventDefault = false;
-    this.event = event5.event;
-    this.windowLabel = event5.windowLabel;
-    this.id = event5.id;
-  }
-  preventDefault() {
-    this._preventDefault = true;
-  }
-  isPreventDefault() {
-    return this._preventDefault;
-  }
-}
-
-class WebviewWindow extends WindowManager {
-  constructor(label, options = {}) {
-    super(label);
-    if (!options?.skip) {
-      invokeTauriCommand({
-        __tauriModule: "Window",
-        message: {
-          cmd: "createWebview",
-          data: {
-            options: {
-              label,
-              ...options
-            }
-          }
-        }
-      }).then(async () => this.emit("tauri://created")).catch(async (e) => this.emit("tauri://error", e));
-    }
-  }
-  static getByLabel(label) {
-    if (getAll().some((w) => w.label === label)) {
-      return new WebviewWindow(label, { skip: true });
-    }
-    return null;
-  }
-  static async getFocusedWindow() {
-    for (const w of getAll()) {
-      if (await w.isFocused()) {
-        return w;
-      }
-    }
-    return null;
-  }
-}
-var appWindow;
-if ("__TAURI_METADATA__" in window) {
-  appWindow = new WebviewWindow(window.__TAURI_METADATA__.__currentWindow.label, {
-    skip: true
-  });
-} else {
-  console.warn(`Could not find "window.__TAURI_METADATA__". The "appWindow" value will reference the "main" window label.\nNote that this is not an issue if running this frontend on a browser instead of a Tauri window.`);
-  appWindow = new WebviewWindow("main", {
-    skip: true
-  });
-}
-
-// src/index.ts
-async function openShell(link) {
-  await open(link);
-}
-
-// src/system-tray.ts
-var testingThis = "testing this";
-
-// src/index.ts
-var desktop = {
-  app: exports_app,
-  event: exports_event,
-  clipboard: exports_clipboard,
-  dialog: exports_dialog,
-  fs: exports_fs,
-  globalShortcut: exports_globalShortcut,
-  http: exports_http,
-  mocks: exports_mocks,
-  notification: exports_notification,
-  os: exports_os,
-  path: exports_path,
-  process: exports_process,
-  shell: exports_shell,
-  tauri: exports_tauri,
-  updater: exports_updater,
-  window: exports_window
-};
-export {
-  testingThis,
-  openShell,
-  desktop
-};