stacks 0.56.24 → 0.58.18

package/core/src/desktop/dist/index.js

@@ -0,0 +1,3075 @@
+// @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
+    });
+};
+
+// /Users/chrisbreuer/Code/stacks/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;
+    }
+  }
+});
+
+// /Users/chrisbreuer/Code/stacks/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);
+};
+
+// /Users/chrisbreuer/Code/stacks/node_modules/@tauri-apps/api/helpers/tauri.js
+async function invokeTauriCommand(command) {
+  return invoke("tauri", command);
+}
+
+// /Users/chrisbreuer/Code/stacks/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);
+    });
+  }
+}
+
+// /Users/chrisbreuer/Code/stacks/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"
+    }
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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;
+    }
+  }
+});
+
+// /Users/chrisbreuer/Code/stacks/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(() => {
+    });
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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 = {}));
+
+// /Users/chrisbreuer/Code/stacks/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
+    }
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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"
+      ]
+    }
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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 = {}));
+
+// /Users/chrisbreuer/Code/stacks/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"
+    }
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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;
+
+// /Users/chrisbreuer/Code/stacks/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__;
+};
+
+// /Users/chrisbreuer/Code/stacks/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);
+  }
+};
+
+// /Users/chrisbreuer/Code/stacks/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;
+    }
+  }
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/@tauri-apps/api/helpers/os-check.js
+var isWindows = function() {
+  return navigator.appVersion.includes("Win");
+};
+
+// /Users/chrisbreuer/Code/stacks/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";
+
+// /Users/chrisbreuer/Code/stacks/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() ? ";" : ":";
+
+// /Users/chrisbreuer/Code/stacks/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"
+    }
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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;
+    });
+  });
+}
+
+// /Users/chrisbreuer/Code/stacks/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);
+}
+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 {
+  openShell,
+  desktop
+};