var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
import { bU as getAugmentedNamespace, bV as getDefaultExportFromCjs } from "./index-bi78Y1IN.js";
const __viteBrowserExternal = {};
const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: __viteBrowserExternal
}, Symbol.toStringTag, { value: "Module" }));
const require$$1 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
var define_process_env_default$1 = {};
const fs = require$$1;
const path = require$$1;
const pathFile = path.join(__dirname, "path.txt");
function getElectronPath() {
  let executablePath;
  if (fs.existsSync(pathFile)) {
    executablePath = fs.readFileSync(pathFile, "utf-8");
  }
  if (define_process_env_default$1.ELECTRON_OVERRIDE_DIST_PATH) {
    return path.join(define_process_env_default$1.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
  }
  if (executablePath) {
    return path.join(__dirname, "dist", executablePath);
  } else {
    throw new Error("Electron failed to install correctly, please delete node_modules/electron and try installing again");
  }
}
__name(getElectronPath, "getElectronPath");
var electron = getElectronPath();
const se = /* @__PURE__ */ getDefaultExportFromCjs(electron);
var define_process_env_default = {};
var re = Object.defineProperty;
var ne = /* @__PURE__ */ __name((s, e, t) => e in s ? re(s, e, { enumerable: true, configurable: true, writable: true, value: t }) : s[e] = t, "ne");
var l = /* @__PURE__ */ __name((s, e, t) => ne(s, typeof e != "symbol" ? e + "" : e, t), "l");
const E = {
  LOADING_PROGRESS: "loading-progress",
  IS_PACKAGED: "is-packaged",
  RENDERER_READY: "renderer-ready",
  RESTART_APP: "restart-app",
  REINSTALL: "reinstall",
  LOG_MESSAGE: "log-message",
  OPEN_DIALOG: "open-dialog",
  DOWNLOAD_PROGRESS: "download-progress",
  START_DOWNLOAD: "start-download",
  PAUSE_DOWNLOAD: "pause-download",
  RESUME_DOWNLOAD: "resume-download",
  CANCEL_DOWNLOAD: "cancel-download",
  DELETE_MODEL: "delete-model",
  GET_ALL_DOWNLOADS: "get-all-downloads",
  GET_ELECTRON_VERSION: "get-electron-version",
  SEND_ERROR_TO_SENTRY: "send-error-to-sentry",
  GET_BASE_PATH: "get-base-path",
  GET_MODEL_CONFIG_PATH: "get-model-config-path",
  OPEN_PATH: "open-path",
  OPEN_LOGS_PATH: "open-logs-path",
  OPEN_DEV_TOOLS: "open-dev-tools",
  IS_FIRST_TIME_SETUP: "is-first-time-setup",
  GET_SYSTEM_PATHS: "get-system-paths",
  VALIDATE_INSTALL_PATH: "validate-install-path",
  VALIDATE_COMFYUI_SOURCE: "validate-comfyui-source",
  SHOW_DIRECTORY_PICKER: "show-directory-picker",
  INSTALL_COMFYUI: "install-comfyui"
};
var oe = /* @__PURE__ */ ((s) => (s.INITIAL_STATE = "initial-state", s.PYTHON_SETUP = "python-setup", s.STARTING_SERVER = "starting-server", s.READY = "ready", s.ERROR = "error", s.ERROR_INSTALL_PATH = "error-install-path", s))(oe || {});
const rr = {
  "initial-state": "Loading...",
  "python-setup": "Setting up Python Environment...",
  "starting-server": "Starting ComfyUI server...",
  ready: "Finishing...",
  error: "Was not able to start ComfyUI. Please check the logs for more details. You can open it from the Help menu. Please report issues to: https://forum.comfy.org",
  "error-install-path": "Installation path does not exist. Please reset the installation location."
}, nr = "electronAPI", sr = "https://942cadba58d247c9cab96f45221aa813@o4507954455314432.ingest.us.sentry.io/4508007940685824", or = [
  {
    id: "user_files",
    label: "User Files",
    description: "Settings and user-created workflows"
  },
  {
    id: "models",
    label: "Models",
    description: "Reference model files from existing ComfyUI installations. (No copy)"
  }
  // TODO: Decide whether we want to auto-migrate custom nodes, and install their dependencies.
  // huchenlei: This is a very essential thing for migration experience.
  // {
  //   id: 'custom_nodes',
  //   label: 'Custom Nodes',
  //   description: 'Reference custom node files from existing ComfyUI installations. (No copy)',
  // },
], ie = {}, ae = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  __proto__: null,
  default: ie
}, Symbol.toStringTag, { value: "Module" }));
function ce(s) {
  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
}
__name(ce, "ce");
function le(s) {
  if (s.__esModule) return s;
  var e = s.default;
  if (typeof e == "function") {
    var t = /* @__PURE__ */ __name(function r() {
      return this instanceof r ? Reflect.construct(e, arguments, this.constructor) : e.apply(this, arguments);
    }, "r");
    t.prototype = e.prototype;
  } else t = {};
  return Object.defineProperty(t, "__esModule", { value: true }), Object.keys(s).forEach(function(r) {
    var n = Object.getOwnPropertyDescriptor(s, r);
    Object.defineProperty(t, r, n.get ? n : {
      enumerable: true,
      get: /* @__PURE__ */ __name(function() {
        return s[r];
      }, "get")
    });
  }), t;
}
__name(le, "le");
const u = /* @__PURE__ */ le(ae), H = u, b = u;
var pe = {
  findAndReadPackageJson: he,
  tryReadJsonAt: P
};
function he() {
  return P(de()) || P(fe()) || P(process.resourcesPath, "app.asar") || P(process.resourcesPath, "app") || P(process.cwd()) || { name: void 0, version: void 0 };
}
__name(he, "he");
function P(...s) {
  if (s[0])
    try {
      const e = b.join(...s), t = ue("package.json", e);
      if (!t)
        return;
      const r = JSON.parse(H.readFileSync(t, "utf8")), n = (r == null ? void 0 : r.productName) || (r == null ? void 0 : r.name);
      return !n || n.toLowerCase() === "electron" ? void 0 : n ? { name: n, version: r == null ? void 0 : r.version } : void 0;
    } catch {
      return;
    }
}
__name(P, "P");
function ue(s, e) {
  let t = e;
  for (; ; ) {
    const r = b.parse(t), n = r.root, o = r.dir;
    if (H.existsSync(b.join(t, s)))
      return b.resolve(b.join(t, s));
    if (t === n)
      return null;
    t = o;
  }
}
__name(ue, "ue");
function fe() {
  const s = process.argv.filter((t) => t.indexOf("--user-data-dir=") === 0);
  return s.length === 0 || typeof s[0] != "string" ? null : s[0].replace("--user-data-dir=", "");
}
__name(fe, "fe");
function de() {
  var s;
  try {
    return (s = require.main) == null ? void 0 : s.filename;
  } catch {
    return;
  }
}
__name(de, "de");
const ge = u, S = u, O = u, me = pe;
let ye = class {
  static {
    __name(this, "ye");
  }
  constructor() {
    l(this, "appName");
    l(this, "appPackageJson");
    l(this, "platform", process.platform);
  }
  getAppLogPath(e = this.getAppName()) {
    return this.platform === "darwin" ? O.join(this.getSystemPathHome(), "Library/Logs", e) : O.join(this.getAppUserDataPath(e), "logs");
  }
  getAppName() {
    var t;
    const e = this.appName || ((t = this.getAppPackageJson()) == null ? void 0 : t.name);
    if (!e)
      throw new Error(
        "electron-log can't determine the app name. It tried these methods:\n1. Use `electron.app.name`\n2. Use productName or name from the nearest package.json`\nYou can also set it through log.transports.file.setAppName()"
      );
    return e;
  }
  /**
   * @private
   * @returns {undefined}
   */
  getAppPackageJson() {
    return typeof this.appPackageJson != "object" && (this.appPackageJson = me.findAndReadPackageJson()), this.appPackageJson;
  }
  getAppUserDataPath(e = this.getAppName()) {
    return e ? O.join(this.getSystemPathAppData(), e) : void 0;
  }
  getAppVersion() {
    var e;
    return (e = this.getAppPackageJson()) == null ? void 0 : e.version;
  }
  getElectronLogPath() {
    return this.getAppLogPath();
  }
  getMacOsVersion() {
    const e = Number(S.release().split(".")[0]);
    return e <= 19 ? `10.${e - 4}` : e - 9;
  }
  /**
   * @protected
   * @returns {string}
   */
  getOsVersion() {
    let e = S.type().replace("_", " "), t = S.release();
    return e === "Darwin" && (e = "macOS", t = this.getMacOsVersion()), `${e} ${t}`;
  }
  /**
   * @return {PathVariables}
   */
  getPathVariables() {
    const e = this.getAppName(), t = this.getAppVersion(), r = this;
    return {
      appData: this.getSystemPathAppData(),
      appName: e,
      appVersion: t,
      get electronDefaultDir() {
        return r.getElectronLogPath();
      },
      home: this.getSystemPathHome(),
      libraryDefaultDir: this.getAppLogPath(e),
      libraryTemplate: this.getAppLogPath("{appName}"),
      temp: this.getSystemPathTemp(),
      userData: this.getAppUserDataPath(e)
    };
  }
  getSystemPathAppData() {
    const e = this.getSystemPathHome();
    switch (this.platform) {
      case "darwin":
        return O.join(e, "Library/Application Support");
      case "win32":
        return define_process_env_default.APPDATA || O.join(e, "AppData/Roaming");
      default:
        return define_process_env_default.XDG_CONFIG_HOME || O.join(e, ".config");
    }
  }
  getSystemPathHome() {
    var e;
    return ((e = S.homedir) == null ? void 0 : e.call(S)) || define_process_env_default.HOME;
  }
  getSystemPathTemp() {
    return S.tmpdir();
  }
  getVersions() {
    return {
      app: `${this.getAppName()} ${this.getAppVersion()}`,
      electron: void 0,
      os: this.getOsVersion()
    };
  }
  isDev() {
    return define_process_env_default.ELECTRON_IS_DEV === "1";
  }
  isElectron() {
    return !!process.versions.electron;
  }
  onAppEvent(e, t) {
  }
  onAppReady(e) {
    e();
  }
  onEveryWebContentsEvent(e, t) {
  }
  /**
   * Listen to async messages sent from opposite process
   * @param {string} channel
   * @param {function} listener
   */
  onIpc(e, t) {
  }
  onIpcInvoke(e, t) {
  }
  /**
   * @param {string} url
   * @param {Function} [logFunction]
   */
  openUrl(e, t = console.error) {
    const n = { darwin: "open", win32: "start", linux: "xdg-open" }[process.platform] || "xdg-open";
    ge.exec(`${n} ${e}`, {}, (o) => {
      o && t(o);
    });
  }
  setAppName(e) {
    this.appName = e;
  }
  setPlatform(e) {
    this.platform = e;
  }
  setPreloadFileForSessions({
    filePath: e,
    // eslint-disable-line no-unused-vars
    includeFutureSession: t = true,
    // eslint-disable-line no-unused-vars
    getSessions: r = /* @__PURE__ */ __name(() => [], "r")
    // eslint-disable-line no-unused-vars
  }) {
  }
  /**
   * Sent a message to opposite process
   * @param {string} channel
   * @param {any} message
   */
  sendIpc(e, t) {
  }
  showErrorBox(e, t) {
  }
};
var ve = ye;
const Ee = u, Se = ve;
let we = class extends Se {
  static {
    __name(this, "we");
  }
  /**
   * @param {object} options
   * @param {typeof Electron} [options.electron]
   */
  constructor({ electron: t } = {}) {
    super();
    l(this, "electron");
    this.electron = t;
  }
  getAppName() {
    var r, n;
    let t;
    try {
      t = this.appName || ((r = this.electron.app) == null ? void 0 : r.name) || ((n = this.electron.app) == null ? void 0 : n.getName());
    } catch {
    }
    return t || super.getAppName();
  }
  getAppUserDataPath(t) {
    return this.getPath("userData") || super.getAppUserDataPath(t);
  }
  getAppVersion() {
    var r;
    let t;
    try {
      t = (r = this.electron.app) == null ? void 0 : r.getVersion();
    } catch {
    }
    return t || super.getAppVersion();
  }
  getElectronLogPath() {
    return this.getPath("logs") || super.getElectronLogPath();
  }
  /**
   * @private
   * @param {any} name
   * @returns {string|undefined}
   */
  getPath(t) {
    var r;
    try {
      return (r = this.electron.app) == null ? void 0 : r.getPath(t);
    } catch {
      return;
    }
  }
  getVersions() {
    return {
      app: `${this.getAppName()} ${this.getAppVersion()}`,
      electron: `Electron ${process.versions.electron}`,
      os: this.getOsVersion()
    };
  }
  getSystemPathAppData() {
    return this.getPath("appData") || super.getSystemPathAppData();
  }
  isDev() {
    var t;
    return ((t = this.electron.app) == null ? void 0 : t.isPackaged) !== void 0 ? !this.electron.app.isPackaged : typeof process.execPath == "string" ? Ee.basename(process.execPath).toLowerCase().startsWith("electron") : super.isDev();
  }
  onAppEvent(t, r) {
    var n;
    return (n = this.electron.app) == null || n.on(t, r), () => {
      var o;
      (o = this.electron.app) == null || o.off(t, r);
    };
  }
  onAppReady(t) {
    var r, n, o;
    (r = this.electron.app) != null && r.isReady() ? t() : (n = this.electron.app) != null && n.once ? (o = this.electron.app) == null || o.once("ready", t) : t();
  }
  onEveryWebContentsEvent(t, r) {
    var o, i, a;
    return (i = (o = this.electron.webContents) == null ? void 0 : o.getAllWebContents()) == null || i.forEach((h) => {
      h.on(t, r);
    }), (a = this.electron.app) == null || a.on("web-contents-created", n), () => {
      var h, c;
      (h = this.electron.webContents) == null || h.getAllWebContents().forEach((p) => {
        p.off(t, r);
      }), (c = this.electron.app) == null || c.off("web-contents-created", n);
    };
    function n(h, c) {
      c.on(t, r);
    }
    __name(n, "n");
  }
  /**
   * Listen to async messages sent from opposite process
   * @param {string} channel
   * @param {function} listener
   */
  onIpc(t, r) {
    var n;
    (n = this.electron.ipcMain) == null || n.on(t, r);
  }
  onIpcInvoke(t, r) {
    var n, o;
    (o = (n = this.electron.ipcMain) == null ? void 0 : n.handle) == null || o.call(n, t, r);
  }
  /**
   * @param {string} url
   * @param {Function} [logFunction]
   */
  openUrl(t, r = console.error) {
    var n;
    (n = this.electron.shell) == null || n.openExternal(t).catch(r);
  }
  setPreloadFileForSessions({
    filePath: t,
    includeFutureSession: r = true,
    getSessions: n = /* @__PURE__ */ __name(() => {
      var o;
      return [(o = this.electron.session) == null ? void 0 : o.defaultSession];
    }, "n")
  }) {
    for (const i of n().filter(Boolean))
      o(i);
    r && this.onAppEvent("session-created", (i) => {
      o(i);
    });
    function o(i) {
      i.setPreloads([...i.getPreloads(), t]);
    }
    __name(o, "o");
  }
  /**
   * Sent a message to opposite process
   * @param {string} channel
   * @param {any} message
   */
  sendIpc(t, r) {
    var n, o;
    (o = (n = this.electron.BrowserWindow) == null ? void 0 : n.getAllWindows()) == null || o.forEach((i) => {
      var a;
      ((a = i.webContents) == null ? void 0 : a.isDestroyed()) === false && i.webContents.send(t, r);
    });
  }
  showErrorBox(t, r) {
    var n;
    (n = this.electron.dialog) == null || n.showErrorBox(t, r);
  }
};
var Oe = we, J = { exports: {} };
(function(s) {
  let e = {};
  try {
    e = require("electron");
  } catch {
  }
  e.ipcRenderer && t(e), s.exports = t;
  function t({ contextBridge: r, ipcRenderer: n }) {
    if (!n)
      return;
    n.on("__ELECTRON_LOG_IPC__", (i, a) => {
      window.postMessage({ cmd: "message", ...a });
    }), n.invoke("__ELECTRON_LOG__", { cmd: "getOptions" }).catch((i) => console.error(new Error(
      `electron-log isn't initialized in the main process. Please call log.initialize() before. ${i.message}`
    )));
    const o = {
      sendToMain(i) {
        try {
          n.send("__ELECTRON_LOG__", i);
        } catch (a) {
          console.error("electronLog.sendToMain ", a, "data:", i), n.send("__ELECTRON_LOG__", {
            cmd: "errorHandler",
            error: { message: a == null ? void 0 : a.message, stack: a == null ? void 0 : a.stack },
            errorName: "sendToMain"
          });
        }
      },
      log(...i) {
        o.sendToMain({ data: i, level: "info" });
      }
    };
    for (const i of ["error", "warn", "info", "verbose", "debug", "silly"])
      o[i] = (...a) => o.sendToMain({
        data: a,
        level: i
      });
    if (r && process.contextIsolated)
      try {
        r.exposeInMainWorld("__electronLog", o);
      } catch {
      }
    typeof window == "object" ? window.__electronLog = o : __electronLog = o;
  }
  __name(t, "t");
})(J);
var Pe = J.exports;
const x = u, Ae = u, C = u, be = Pe;
var Le = {
  initialize({
    externalApi: s,
    getSessions: e,
    includeFutureSession: t,
    logger: r,
    preload: n = true,
    spyRendererConsole: o = false
  }) {
    s.onAppReady(() => {
      try {
        n && De({
          externalApi: s,
          getSessions: e,
          includeFutureSession: t,
          preloadOption: n
        }), o && _e({ externalApi: s, logger: r });
      } catch (i) {
        r.warn(i);
      }
    });
  }
};
function De({
  externalApi: s,
  getSessions: e,
  includeFutureSession: t,
  preloadOption: r
}) {
  let n = typeof r == "string" ? r : void 0;
  try {
    n = C.resolve(
      __dirname,
      "../renderer/electron-log-preload.js"
    );
  } catch {
  }
  if (!n || !x.existsSync(n)) {
    n = C.join(
      s.getAppUserDataPath() || Ae.tmpdir(),
      "electron-log-preload.js"
    );
    const o = `
      try {
        (${be.toString()})(require('electron'));
      } catch(e) {
        console.error(e);
      }
    `;
    x.writeFileSync(n, o, "utf8");
  }
  s.setPreloadFileForSessions({
    filePath: n,
    includeFutureSession: t,
    getSessions: e
  });
}
__name(De, "De");
function _e({ externalApi: s, logger: e }) {
  const t = ["verbose", "info", "warning", "error"];
  s.onEveryWebContentsEvent(
    "console-message",
    (r, n, o) => {
      e.processMessage({
        data: [o],
        level: t[n],
        variables: { processType: "renderer" }
      });
    }
  );
}
__name(_e, "_e");
var Ne = $e;
function $e(s) {
  return Object.defineProperties(e, {
    defaultLabel: { value: "", writable: true },
    labelPadding: { value: true, writable: true },
    maxLabelLength: { value: 0, writable: true },
    labelLength: {
      get() {
        switch (typeof e.labelPadding) {
          case "boolean":
            return e.labelPadding ? e.maxLabelLength : 0;
          case "number":
            return e.labelPadding;
          default:
            return 0;
        }
      }
    }
  });
  function e(t) {
    e.maxLabelLength = Math.max(e.maxLabelLength, t.length);
    const r = {};
    for (const n of [...s.levels, "log"])
      r[n] = (...o) => s.logData(o, { level: n, scope: t });
    return r;
  }
  __name(e, "e");
}
__name($e, "$e");
const Te = Ne;
var v;
let Fe = (v = class {
  static {
    __name(this, "v");
  }
  constructor({
    allowUnknownLevel: e = false,
    dependencies: t = {},
    errorHandler: r,
    eventLogger: n,
    initializeFn: o,
    isDev: i = false,
    levels: a = ["error", "warn", "info", "verbose", "debug", "silly"],
    logId: h,
    transportFactories: c = {},
    variables: p
  } = {}) {
    l(this, "dependencies", {});
    l(this, "errorHandler", null);
    l(this, "eventLogger", null);
    l(this, "functions", {});
    l(this, "hooks", []);
    l(this, "isDev", false);
    l(this, "levels", null);
    l(this, "logId", null);
    l(this, "scope", null);
    l(this, "transports", {});
    l(this, "variables", {});
    this.addLevel = this.addLevel.bind(this), this.create = this.create.bind(this), this.initialize = this.initialize.bind(this), this.logData = this.logData.bind(this), this.processMessage = this.processMessage.bind(this), this.allowUnknownLevel = e, this.dependencies = t, this.initializeFn = o, this.isDev = i, this.levels = a, this.logId = h, this.transportFactories = c, this.variables = p || {}, this.scope = Te(this);
    for (const f of this.levels)
      this.addLevel(f, false);
    this.log = this.info, this.functions.log = this.log, this.errorHandler = r, r == null || r.setOptions({ ...t, logFn: this.error }), this.eventLogger = n, n == null || n.setOptions({ ...t, logger: this });
    for (const [f, g] of Object.entries(c))
      this.transports[f] = g(this, t);
    v.instances[h] = this;
  }
  static getInstance({ logId: e }) {
    return this.instances[e] || this.instances.default;
  }
  addLevel(e, t = this.levels.length) {
    t !== false && this.levels.splice(t, 0, e), this[e] = (...r) => this.logData(r, { level: e }), this.functions[e] = this[e];
  }
  catchErrors(e) {
    return this.processMessage(
      {
        data: ["log.catchErrors is deprecated. Use log.errorHandler instead"],
        level: "warn"
      },
      { transports: ["console"] }
    ), this.errorHandler.startCatching(e);
  }
  create(e) {
    return typeof e == "string" && (e = { logId: e }), new v({
      dependencies: this.dependencies,
      errorHandler: this.errorHandler,
      initializeFn: this.initializeFn,
      isDev: this.isDev,
      transportFactories: this.transportFactories,
      variables: { ...this.variables },
      ...e
    });
  }
  compareLevels(e, t, r = this.levels) {
    const n = r.indexOf(e), o = r.indexOf(t);
    return o === -1 || n === -1 ? true : o <= n;
  }
  initialize(e = {}) {
    this.initializeFn({ logger: this, ...this.dependencies, ...e });
  }
  logData(e, t = {}) {
    this.processMessage({ data: e, ...t });
  }
  processMessage(e, { transports: t = this.transports } = {}) {
    if (e.cmd === "errorHandler") {
      this.errorHandler.handle(e.error, {
        errorName: e.errorName,
        processType: "renderer",
        showDialog: !!e.showDialog
      });
      return;
    }
    let r = e.level;
    this.allowUnknownLevel || (r = this.levels.includes(e.level) ? e.level : "info");
    const n = {
      date: /* @__PURE__ */ new Date(),
      ...e,
      level: r,
      variables: {
        ...this.variables,
        ...e.variables
      }
    };
    for (const [o, i] of this.transportEntries(t))
      if (!(typeof i != "function" || i.level === false) && this.compareLevels(i.level, e.level))
        try {
          const a = this.hooks.reduce((h, c) => h && c(h, i, o), n);
          a && i({ ...a, data: [...a.data] });
        } catch (a) {
          this.processInternalErrorFn(a);
        }
  }
  processInternalErrorFn(e) {
  }
  transportEntries(e = this.transports) {
    return (Array.isArray(e) ? e : Object.entries(e)).map((r) => {
      switch (typeof r) {
        case "string":
          return this.transports[r] ? [r, this.transports[r]] : null;
        case "function":
          return [r.name, r];
        default:
          return Array.isArray(r) ? r : null;
      }
    }).filter(Boolean);
  }
}, l(v, "instances", {}), v);
var Re = Fe;
let Ie = class {
  static {
    __name(this, "Ie");
  }
  constructor({
    externalApi: e,
    logFn: t = void 0,
    onError: r = void 0,
    showDialog: n = void 0
  } = {}) {
    l(this, "externalApi");
    l(this, "isActive", false);
    l(this, "logFn");
    l(this, "onError");
    l(this, "showDialog", true);
    this.createIssue = this.createIssue.bind(this), this.handleError = this.handleError.bind(this), this.handleRejection = this.handleRejection.bind(this), this.setOptions({ externalApi: e, logFn: t, onError: r, showDialog: n }), this.startCatching = this.startCatching.bind(this), this.stopCatching = this.stopCatching.bind(this);
  }
  handle(e, {
    logFn: t = this.logFn,
    onError: r = this.onError,
    processType: n = "browser",
    showDialog: o = this.showDialog,
    errorName: i = ""
  } = {}) {
    var a;
    e = xe(e);
    try {
      if (typeof r == "function") {
        const h = ((a = this.externalApi) == null ? void 0 : a.getVersions()) || {}, c = this.createIssue;
        if (r({
          createIssue: c,
          error: e,
          errorName: i,
          processType: n,
          versions: h
        }) === false)
          return;
      }
      i ? t(i, e) : t(e), o && !i.includes("rejection") && this.externalApi && this.externalApi.showErrorBox(
        `A JavaScript error occurred in the ${n} process`,
        e.stack
      );
    } catch {
      console.error(e);
    }
  }
  setOptions({ externalApi: e, logFn: t, onError: r, showDialog: n }) {
    typeof e == "object" && (this.externalApi = e), typeof t == "function" && (this.logFn = t), typeof r == "function" && (this.onError = r), typeof n == "boolean" && (this.showDialog = n);
  }
  startCatching({ onError: e, showDialog: t } = {}) {
    this.isActive || (this.isActive = true, this.setOptions({ onError: e, showDialog: t }), process.on("uncaughtException", this.handleError), process.on("unhandledRejection", this.handleRejection));
  }
  stopCatching() {
    this.isActive = false, process.removeListener("uncaughtException", this.handleError), process.removeListener("unhandledRejection", this.handleRejection);
  }
  createIssue(e, t) {
    var r;
    (r = this.externalApi) == null || r.openUrl(
      `${e}?${new URLSearchParams(t).toString()}`
    );
  }
  handleError(e) {
    this.handle(e, { errorName: "Unhandled" });
  }
  handleRejection(e) {
    const t = e instanceof Error ? e : new Error(JSON.stringify(e));
    this.handle(t, { errorName: "Unhandled rejection" });
  }
};
function xe(s) {
  if (s instanceof Error)
    return s;
  if (s && typeof s == "object") {
    if (s.message)
      return Object.assign(new Error(s.message), s);
    try {
      return new Error(JSON.stringify(s));
    } catch (e) {
      return new Error(`Couldn't normalize error ${String(s)}: ${e}`);
    }
  }
  return new Error(`Can't normalize error ${String(s)}`);
}
__name(xe, "xe");
var Ce = Ie;
let je = class {
  static {
    __name(this, "je");
  }
  constructor(e = {}) {
    l(this, "disposers", []);
    l(this, "format", "{eventSource}#{eventName}:");
    l(this, "formatters", {
      app: {
        "certificate-error": /* @__PURE__ */ __name(({ args: e2 }) => this.arrayToObject(e2.slice(1, 4), [
          "url",
          "error",
          "certificate"
        ]), "certificate-error"),
        "child-process-gone": /* @__PURE__ */ __name(({ args: e2 }) => e2.length === 1 ? e2[0] : e2, "child-process-gone"),
        "render-process-gone": /* @__PURE__ */ __name(({ args: [e2, t] }) => t && typeof t == "object" ? { ...t, ...this.getWebContentsDetails(e2) } : [], "render-process-gone")
      },
      webContents: {
        "console-message": /* @__PURE__ */ __name(({ args: [e2, t, r, n] }) => {
          if (!(e2 < 3))
            return { message: t, source: `${n}:${r}` };
        }, "console-message"),
        "did-fail-load": /* @__PURE__ */ __name(({ args: e2 }) => this.arrayToObject(e2, [
          "errorCode",
          "errorDescription",
          "validatedURL",
          "isMainFrame",
          "frameProcessId",
          "frameRoutingId"
        ]), "did-fail-load"),
        "did-fail-provisional-load": /* @__PURE__ */ __name(({ args: e2 }) => this.arrayToObject(e2, [
          "errorCode",
          "errorDescription",
          "validatedURL",
          "isMainFrame",
          "frameProcessId",
          "frameRoutingId"
        ]), "did-fail-provisional-load"),
        "plugin-crashed": /* @__PURE__ */ __name(({ args: e2 }) => this.arrayToObject(e2, ["name", "version"]), "plugin-crashed"),
        "preload-error": /* @__PURE__ */ __name(({ args: e2 }) => this.arrayToObject(e2, ["preloadPath", "error"]), "preload-error")
      }
    });
    l(this, "events", {
      app: {
        "certificate-error": true,
        "child-process-gone": true,
        "render-process-gone": true
      },
      webContents: {
        // 'console-message': true,
        "did-fail-load": true,
        "did-fail-provisional-load": true,
        "plugin-crashed": true,
        "preload-error": true,
        unresponsive: true
      }
    });
    l(this, "externalApi");
    l(this, "level", "error");
    l(this, "scope", "");
    this.setOptions(e);
  }
  setOptions({
    events: e,
    externalApi: t,
    level: r,
    logger: n,
    format: o,
    formatters: i,
    scope: a
  }) {
    typeof e == "object" && (this.events = e), typeof t == "object" && (this.externalApi = t), typeof r == "string" && (this.level = r), typeof n == "object" && (this.logger = n), (typeof o == "string" || typeof o == "function") && (this.format = o), typeof i == "object" && (this.formatters = i), typeof a == "string" && (this.scope = a);
  }
  startLogging(e = {}) {
    this.setOptions(e), this.disposeListeners();
    for (const t of this.getEventNames(this.events.app))
      this.disposers.push(
        this.externalApi.onAppEvent(t, (...r) => {
          this.handleEvent({ eventSource: "app", eventName: t, handlerArgs: r });
        })
      );
    for (const t of this.getEventNames(this.events.webContents))
      this.disposers.push(
        this.externalApi.onEveryWebContentsEvent(
          t,
          (...r) => {
            this.handleEvent(
              { eventSource: "webContents", eventName: t, handlerArgs: r }
            );
          }
        )
      );
  }
  stopLogging() {
    this.disposeListeners();
  }
  arrayToObject(e, t) {
    const r = {};
    return t.forEach((n, o) => {
      r[n] = e[o];
    }), e.length > t.length && (r.unknownArgs = e.slice(t.length)), r;
  }
  disposeListeners() {
    this.disposers.forEach((e) => e()), this.disposers = [];
  }
  formatEventLog({ eventName: e, eventSource: t, handlerArgs: r }) {
    var p;
    const [n, ...o] = r;
    if (typeof this.format == "function")
      return this.format({ args: o, event: n, eventName: e, eventSource: t });
    const i = (p = this.formatters[t]) == null ? void 0 : p[e];
    let a = o;
    if (typeof i == "function" && (a = i({ args: o, event: n, eventName: e, eventSource: t })), !a)
      return;
    const h = {};
    return Array.isArray(a) ? h.args = a : typeof a == "object" && Object.assign(h, a), t === "webContents" && Object.assign(h, this.getWebContentsDetails(n == null ? void 0 : n.sender)), [this.format.replace("{eventSource}", t === "app" ? "App" : "WebContents").replace("{eventName}", e), h];
  }
  getEventNames(e) {
    return !e || typeof e != "object" ? [] : Object.entries(e).filter(([t, r]) => r).map(([t]) => t);
  }
  getWebContentsDetails(e) {
    if (!(e != null && e.loadURL))
      return {};
    try {
      return {
        webContents: {
          id: e.id,
          url: e.getURL()
        }
      };
    } catch {
      return {};
    }
  }
  handleEvent({ eventName: e, eventSource: t, handlerArgs: r }) {
    var o;
    const n = this.formatEventLog({ eventName: e, eventSource: t, handlerArgs: r });
    if (n) {
      const i = this.scope ? this.logger.scope(this.scope) : this.logger;
      (o = i == null ? void 0 : i[this.level]) == null || o.call(i, ...n);
    }
  }
};
var Me = je, L = { transform: We };
function We({
  logger: s,
  message: e,
  transport: t,
  initialData: r = (e == null ? void 0 : e.data) || [],
  transforms: n = t == null ? void 0 : t.transforms
}) {
  return n.reduce((o, i) => typeof i == "function" ? i({ data: o, logger: s, message: e, transport: t }) : o, r);
}
__name(We, "We");
const { transform: ze } = L;
var Y = {
  concatFirstStringElements: Ue,
  formatScope: j,
  formatText: W,
  formatVariables: M,
  timeZoneFromOffset: q,
  format({ message: s, logger: e, transport: t, data: r = s == null ? void 0 : s.data }) {
    switch (typeof t.format) {
      case "string":
        return ze({
          message: s,
          logger: e,
          transforms: [M, j, W],
          transport: t,
          initialData: [t.format, ...r]
        });
      case "function":
        return t.format({
          data: r,
          level: (s == null ? void 0 : s.level) || "info",
          logger: e,
          message: s,
          transport: t
        });
      default:
        return r;
    }
  }
};
function Ue({ data: s }) {
  return typeof s[0] != "string" || typeof s[1] != "string" || s[0].match(/%[1cdfiOos]/) ? s : [`${s[0]} ${s[1]}`, ...s.slice(2)];
}
__name(Ue, "Ue");
function q(s) {
  const e = Math.abs(s), t = s >= 0 ? "-" : "+", r = Math.floor(e / 60).toString().padStart(2, "0"), n = (e % 60).toString().padStart(2, "0");
  return `${t}${r}:${n}`;
}
__name(q, "q");
function j({ data: s, logger: e, message: t }) {
  const { defaultLabel: r, labelLength: n } = (e == null ? void 0 : e.scope) || {}, o = s[0];
  let i = t.scope;
  i || (i = r);
  let a;
  return i === "" ? a = n > 0 ? "".padEnd(n + 3) : "" : typeof i == "string" ? a = ` (${i})`.padEnd(n + 3) : a = "", s[0] = o.replace("{scope}", a), s;
}
__name(j, "j");
function M({ data: s, message: e }) {
  let t = s[0];
  if (typeof t != "string")
    return s;
  t = t.replace("{level}]", `${e.level}]`.padEnd(6, " "));
  const r = e.date || /* @__PURE__ */ new Date();
  return s[0] = t.replace(/\{(\w+)}/g, (n, o) => {
    var i;
    switch (o) {
      case "level":
        return e.level || "info";
      case "logId":
        return e.logId;
      case "y":
        return r.getFullYear().toString(10);
      case "m":
        return (r.getMonth() + 1).toString(10).padStart(2, "0");
      case "d":
        return r.getDate().toString(10).padStart(2, "0");
      case "h":
        return r.getHours().toString(10).padStart(2, "0");
      case "i":
        return r.getMinutes().toString(10).padStart(2, "0");
      case "s":
        return r.getSeconds().toString(10).padStart(2, "0");
      case "ms":
        return r.getMilliseconds().toString(10).padStart(3, "0");
      case "z":
        return q(r.getTimezoneOffset());
      case "iso":
        return r.toISOString();
      default:
        return ((i = e.variables) == null ? void 0 : i[o]) || n;
    }
  }).trim(), s;
}
__name(M, "M");
function W({ data: s }) {
  const e = s[0];
  if (typeof e != "string")
    return s;
  if (e.lastIndexOf("{text}") === e.length - 6)
    return s[0] = e.replace(/\s?{text}/, ""), s[0] === "" && s.shift(), s;
  const r = e.split("{text}");
  let n = [];
  return r[0] !== "" && n.push(r[0]), n = n.concat(s.slice(1)), r[1] !== "" && n.push(r[1]), n;
}
__name(W, "W");
var Q = { exports: {} };
(function(s) {
  const e = u;
  s.exports = {
    serialize: r,
    maxDepth({ data: n, transport: o, depth: i = (o == null ? void 0 : o.depth) ?? 6 }) {
      if (!n)
        return n;
      if (i < 1)
        return Array.isArray(n) ? "[array]" : typeof n == "object" && n ? "[object]" : n;
      if (Array.isArray(n))
        return n.map((h) => s.exports.maxDepth({
          data: h,
          depth: i - 1
        }));
      if (typeof n != "object" || n && typeof n.toISOString == "function")
        return n;
      if (n === null)
        return null;
      if (n instanceof Error)
        return n;
      const a = {};
      for (const h in n)
        Object.prototype.hasOwnProperty.call(n, h) && (a[h] = s.exports.maxDepth({
          data: n[h],
          depth: i - 1
        }));
      return a;
    },
    toJSON({ data: n }) {
      return JSON.parse(JSON.stringify(n, t()));
    },
    toString({ data: n, transport: o }) {
      const i = (o == null ? void 0 : o.inspectOptions) || {}, a = n.map((h) => {
        if (h !== void 0)
          try {
            const c = JSON.stringify(h, t(), "  ");
            return c === void 0 ? void 0 : JSON.parse(c);
          } catch {
            return h;
          }
      });
      return e.formatWithOptions(i, ...a);
    }
  };
  function t(n = {}) {
    const o = /* @__PURE__ */ new WeakSet();
    return function(i, a) {
      if (typeof a == "object" && a !== null) {
        if (o.has(a))
          return;
        o.add(a);
      }
      return r(i, a, n);
    };
  }
  __name(t, "t");
  function r(n, o, i = {}) {
    const a = (i == null ? void 0 : i.serializeMapAndSet) !== false;
    return o instanceof Error ? o.stack : o && (typeof o == "function" ? `[function] ${o.toString()}` : o instanceof Date ? o.toISOString() : a && o instanceof Map && Object.fromEntries ? Object.fromEntries(o) : a && o instanceof Set && Array.from ? Array.from(o) : o);
  }
  __name(r, "r");
})(Q);
var _ = Q.exports, T = {
  transformStyles: $,
  applyAnsiStyles({ data: s }) {
    return $(s, ke, Ve);
  },
  removeStyles({ data: s }) {
    return $(s, () => "");
  }
};
const K = {
  unset: "\x1B[0m",
  black: "\x1B[30m",
  red: "\x1B[31m",
  green: "\x1B[32m",
  yellow: "\x1B[33m",
  blue: "\x1B[34m",
  magenta: "\x1B[35m",
  cyan: "\x1B[36m",
  white: "\x1B[37m"
};
function ke(s) {
  const e = s.replace(/color:\s*(\w+).*/, "$1").toLowerCase();
  return K[e] || "";
}
__name(ke, "ke");
function Ve(s) {
  return s + K.unset;
}
__name(Ve, "Ve");
function $(s, e, t) {
  const r = {};
  return s.reduce((n, o, i, a) => {
    if (r[i])
      return n;
    if (typeof o == "string") {
      let h = i, c = false;
      o = o.replace(/%[1cdfiOos]/g, (p) => {
        if (h += 1, p !== "%c")
          return p;
        const f = a[h];
        return typeof f == "string" ? (r[h] = true, c = true, e(f, o)) : p;
      }), c && t && (o = t(o));
    }
    return n.push(o), n;
  }, []);
}
__name($, "$");
const { concatFirstStringElements: Be, format: Ge } = Y, { maxDepth: He, toJSON: Je } = _, { applyAnsiStyles: Ye, removeStyles: qe } = T, { transform: Qe } = L, z = {
  error: console.error,
  warn: console.warn,
  info: console.info,
  verbose: console.info,
  debug: console.debug,
  silly: console.debug,
  log: console.log
};
var Ke = X;
const Xe = process.platform === "win32" ? ">" : "›", F = `%c{h}:{i}:{s}.{ms}{scope}%c ${Xe} {text}`;
Object.assign(X, {
  DEFAULT_FORMAT: F
});
function X(s) {
  return Object.assign(e, {
    format: F,
    level: "silly",
    transforms: [
      Ze,
      Ge,
      tt,
      Be,
      He,
      Je
    ],
    useStyles: define_process_env_default.FORCE_STYLES,
    writeFn({ message: t }) {
      (z[t.level] || z.info)(...t.data);
    }
  });
  function e(t) {
    const r = Qe({ logger: s, message: t, transport: e });
    e.writeFn({
      message: { ...t, data: r }
    });
  }
  __name(e, "e");
}
__name(X, "X");
function Ze({ data: s, message: e, transport: t }) {
  return t.format !== F ? s : [`color:${rt(e.level)}`, "color:unset", ...s];
}
__name(Ze, "Ze");
function et(s, e) {
  if (typeof s == "boolean")
    return s;
  const r = e === "error" || e === "warn" ? process.stderr : process.stdout;
  return r && r.isTTY;
}
__name(et, "et");
function tt(s) {
  const { message: e, transport: t } = s;
  return (et(t.useStyles, e.level) ? Ye : qe)(s);
}
__name(tt, "tt");
function rt(s) {
  const e = { error: "red", warn: "yellow", info: "cyan", default: "unset" };
  return e[s] || e.default;
}
__name(rt, "rt");
const nt = u, y = u, U = u;
let st = class extends nt {
  static {
    __name(this, "st");
  }
  constructor({
    path: t,
    writeOptions: r = { encoding: "utf8", flag: "a", mode: 438 },
    writeAsync: n = false
  }) {
    super();
    l(this, "asyncWriteQueue", []);
    l(this, "bytesWritten", 0);
    l(this, "hasActiveAsyncWriting", false);
    l(this, "path", null);
    l(this, "initialSize");
    l(this, "writeOptions", null);
    l(this, "writeAsync", false);
    this.path = t, this.writeOptions = r, this.writeAsync = n;
  }
  get size() {
    return this.getSize();
  }
  clear() {
    try {
      return y.writeFileSync(this.path, "", {
        mode: this.writeOptions.mode,
        flag: "w"
      }), this.reset(), true;
    } catch (t) {
      return t.code === "ENOENT" ? true : (this.emit("error", t, this), false);
    }
  }
  crop(t) {
    try {
      const r = ot(this.path, t || 4096);
      this.clear(), this.writeLine(`[log cropped]${U.EOL}${r}`);
    } catch (r) {
      this.emit(
        "error",
        new Error(`Couldn't crop file ${this.path}. ${r.message}`),
        this
      );
    }
  }
  getSize() {
    if (this.initialSize === void 0)
      try {
        const t = y.statSync(this.path);
        this.initialSize = t.size;
      } catch {
        this.initialSize = 0;
      }
    return this.initialSize + this.bytesWritten;
  }
  increaseBytesWrittenCounter(t) {
    this.bytesWritten += Buffer.byteLength(t, this.writeOptions.encoding);
  }
  isNull() {
    return false;
  }
  nextAsyncWrite() {
    const t = this;
    if (this.hasActiveAsyncWriting || this.asyncWriteQueue.length === 0)
      return;
    const r = this.asyncWriteQueue.join("");
    this.asyncWriteQueue = [], this.hasActiveAsyncWriting = true, y.writeFile(this.path, r, this.writeOptions, (n) => {
      t.hasActiveAsyncWriting = false, n ? t.emit(
        "error",
        new Error(`Couldn't write to ${t.path}. ${n.message}`),
        this
      ) : t.increaseBytesWrittenCounter(r), t.nextAsyncWrite();
    });
  }
  reset() {
    this.initialSize = void 0, this.bytesWritten = 0;
  }
  toString() {
    return this.path;
  }
  writeLine(t) {
    if (t += U.EOL, this.writeAsync) {
      this.asyncWriteQueue.push(t), this.nextAsyncWrite();
      return;
    }
    try {
      y.writeFileSync(this.path, t, this.writeOptions), this.increaseBytesWrittenCounter(t);
    } catch (r) {
      this.emit(
        "error",
        new Error(`Couldn't write to ${this.path}. ${r.message}`),
        this
      );
    }
  }
};
var Z = st;
function ot(s, e) {
  const t = Buffer.alloc(e), r = y.statSync(s), n = Math.min(r.size, e), o = Math.max(0, r.size - e), i = y.openSync(s, "r"), a = y.readSync(i, t, 0, n, o);
  return y.closeSync(i), t.toString("utf8", 0, a);
}
__name(ot, "ot");
const it = Z;
let at = class extends it {
  static {
    __name(this, "at");
  }
  clear() {
  }
  crop() {
  }
  getSize() {
    return 0;
  }
  isNull() {
    return true;
  }
  writeLine() {
  }
};
var ct = at;
const lt = u, k = u, V = u, pt = Z, ht = ct;
let ut = class extends lt {
  static {
    __name(this, "ut");
  }
  constructor() {
    super();
    l(this, "store", {});
    this.emitError = this.emitError.bind(this);
  }
  /**
   * Provide a File object corresponding to the filePath
   * @param {string} filePath
   * @param {WriteOptions} [writeOptions]
   * @param {boolean} [writeAsync]
   * @return {File}
   */
  provide({ filePath: t, writeOptions: r = {}, writeAsync: n = false }) {
    let o;
    try {
      if (t = V.resolve(t), this.store[t])
        return this.store[t];
      o = this.createFile({ filePath: t, writeOptions: r, writeAsync: n });
    } catch (i) {
      o = new ht({ path: t }), this.emitError(i, o);
    }
    return o.on("error", this.emitError), this.store[t] = o, o;
  }
  /**
   * @param {string} filePath
   * @param {WriteOptions} writeOptions
   * @param {boolean} async
   * @return {File}
   * @private
   */
  createFile({ filePath: t, writeOptions: r, writeAsync: n }) {
    return this.testFileWriting({ filePath: t, writeOptions: r }), new pt({ path: t, writeOptions: r, writeAsync: n });
  }
  /**
   * @param {Error} error
   * @param {File} file
   * @private
   */
  emitError(t, r) {
    this.emit("error", t, r);
  }
  /**
   * @param {string} filePath
   * @param {WriteOptions} writeOptions
   * @private
   */
  testFileWriting({ filePath: t, writeOptions: r }) {
    k.mkdirSync(V.dirname(t), { recursive: true }), k.writeFileSync(t, "", { flag: "a", mode: r.mode });
  }
};
var ft = ut;
const D = u, dt = u, A = u, gt = ft, { transform: mt } = L, { removeStyles: yt } = T, {
  format: vt,
  concatFirstStringElements: Et
} = Y, { toString: St } = _;
var wt = Pt;
const Ot = new gt();
function Pt(s, { registry: e = Ot, externalApi: t } = {}) {
  let r;
  return e.listenerCount("error") < 1 && e.on("error", (c, p) => {
    i(`Can't write to ${p}`, c);
  }), Object.assign(n, {
    fileName: At(s.variables.processType),
    format: "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}]{scope} {text}",
    getFile: a,
    inspectOptions: { depth: 5 },
    level: "silly",
    maxSize: 1024 ** 2,
    readAllLogs: h,
    sync: true,
    transforms: [yt, vt, Et, St],
    writeOptions: { flag: "a", mode: 438, encoding: "utf8" },
    archiveLogFn(c) {
      const p = c.toString(), f = A.parse(p);
      try {
        D.renameSync(p, A.join(f.dir, `${f.name}.old${f.ext}`));
      } catch (g) {
        i("Could not rotate log", g);
        const te = Math.round(n.maxSize / 4);
        c.crop(Math.min(te, 256 * 1024));
      }
    },
    resolvePathFn(c) {
      return A.join(c.libraryDefaultDir, c.fileName);
    },
    setAppName(c) {
      s.dependencies.externalApi.setAppName(c);
    }
  });
  function n(c) {
    const p = a(c);
    n.maxSize > 0 && p.size > n.maxSize && (n.archiveLogFn(p), p.reset());
    const g = mt({ logger: s, message: c, transport: n });
    p.writeLine(g);
  }
  __name(n, "n");
  function o() {
    r || (r = Object.create(
      Object.prototype,
      {
        ...Object.getOwnPropertyDescriptors(
          t.getPathVariables()
        ),
        fileName: {
          get() {
            return n.fileName;
          },
          enumerable: true
        }
      }
    ), typeof n.archiveLog == "function" && (n.archiveLogFn = n.archiveLog, i("archiveLog is deprecated. Use archiveLogFn instead")), typeof n.resolvePath == "function" && (n.resolvePathFn = n.resolvePath, i("resolvePath is deprecated. Use resolvePathFn instead")));
  }
  __name(o, "o");
  function i(c, p = null, f = "error") {
    const g = [`electron-log.transports.file: ${c}`];
    p && g.push(p), s.transports.console({ data: g, date: /* @__PURE__ */ new Date(), level: f });
  }
  __name(i, "i");
  function a(c) {
    o();
    const p = n.resolvePathFn(r, c);
    return e.provide({
      filePath: p,
      writeAsync: !n.sync,
      writeOptions: n.writeOptions
    });
  }
  __name(a, "a");
  function h({ fileFilter: c = /* @__PURE__ */ __name((p) => p.endsWith(".log"), "c") } = {}) {
    o();
    const p = A.dirname(n.resolvePathFn(r));
    return D.existsSync(p) ? D.readdirSync(p).map((f) => A.join(p, f)).filter(c).map((f) => {
      try {
        return {
          path: f,
          lines: D.readFileSync(f, "utf8").split(dt.EOL)
        };
      } catch {
        return null;
      }
    }).filter(Boolean) : [];
  }
  __name(h, "h");
}
__name(Pt, "Pt");
function At(s = process.type) {
  switch (s) {
    case "renderer":
      return "renderer.log";
    case "worker":
      return "worker.log";
    default:
      return "main.log";
  }
}
__name(At, "At");
const { maxDepth: bt, toJSON: Lt } = _, { transform: Dt } = L;
var _t = Nt;
function Nt(s, { externalApi: e }) {
  return Object.assign(t, {
    depth: 3,
    eventId: "__ELECTRON_LOG_IPC__",
    level: s.isDev ? "silly" : false,
    transforms: [Lt, bt]
  }), e != null && e.isElectron() ? t : void 0;
  function t(r) {
    var n;
    ((n = r == null ? void 0 : r.variables) == null ? void 0 : n.processType) !== "renderer" && (e == null || e.sendIpc(t.eventId, {
      ...r,
      data: Dt({ logger: s, message: r, transport: t })
    }));
  }
  __name(t, "t");
}
__name(Nt, "Nt");
const $t = u, Tt = u, { transform: Ft } = L, { removeStyles: Rt } = T, { toJSON: It, maxDepth: xt } = _;
var Ct = jt;
function jt(s) {
  return Object.assign(e, {
    client: { name: "electron-application" },
    depth: 6,
    level: false,
    requestOptions: {},
    transforms: [Rt, It, xt],
    makeBodyFn({ message: t }) {
      return JSON.stringify({
        client: e.client,
        data: t.data,
        date: t.date.getTime(),
        level: t.level,
        scope: t.scope,
        variables: t.variables
      });
    },
    processErrorFn({ error: t }) {
      s.processMessage(
        {
          data: [`electron-log: can't POST ${e.url}`, t],
          level: "warn"
        },
        { transports: ["console", "file"] }
      );
    },
    sendRequestFn({ serverUrl: t, requestOptions: r, body: n }) {
      const i = (t.startsWith("https:") ? Tt : $t).request(t, {
        method: "POST",
        ...r,
        headers: {
          "Content-Type": "application/json",
          "Content-Length": n.length,
          ...r.headers
        }
      });
      return i.write(n), i.end(), i;
    }
  });
  function e(t) {
    if (!e.url)
      return;
    const r = e.makeBodyFn({
      logger: s,
      message: { ...t, data: Ft({ logger: s, message: t, transport: e }) },
      transport: e
    }), n = e.sendRequestFn({
      serverUrl: e.url,
      requestOptions: e.requestOptions,
      body: Buffer.from(r, "utf8")
    });
    n.on("error", (o) => e.processErrorFn({
      error: o,
      logger: s,
      message: t,
      request: n,
      transport: e
    }));
  }
  __name(e, "e");
}
__name(jt, "jt");
const B = Re, Mt = Ce, Wt = Me, zt = Ke, Ut = wt, kt = _t, Vt = Ct;
var Bt = Gt;
function Gt({ dependencies: s, initializeFn: e }) {
  var r;
  const t = new B({
    dependencies: s,
    errorHandler: new Mt(),
    eventLogger: new Wt(),
    initializeFn: e,
    isDev: (r = s.externalApi) == null ? void 0 : r.isDev(),
    logId: "default",
    transportFactories: {
      console: zt,
      file: Ut,
      ipc: kt,
      remote: Vt
    },
    variables: {
      processType: "main"
    }
  });
  return t.default = t, t.Logger = B, t.processInternalErrorFn = (n) => {
    t.transports.console.writeFn({
      message: {
        data: ["Unhandled electron-log error", n],
        level: "error"
      }
    });
  }, t;
}
__name(Gt, "Gt");
const Ht = se, Jt = Oe, { initialize: Yt } = Le, qt = Bt, R = new Jt({ electron: Ht }), N = qt({
  dependencies: { externalApi: R },
  initializeFn: Yt
});
var Qt = N;
R.onIpc("__ELECTRON_LOG__", (s, e) => {
  e.scope && N.Logger.getInstance(e).scope(e.scope);
  const t = new Date(e.date);
  ee({
    ...e,
    date: t.getTime() ? t : /* @__PURE__ */ new Date()
  });
});
R.onIpcInvoke("__ELECTRON_LOG__", (s, { cmd: e = "", logId: t }) => {
  switch (e) {
    case "getOptions":
      return {
        levels: N.Logger.getInstance({ logId: t }).levels,
        logId: t
      };
    default:
      return ee({ data: [`Unknown cmd '${e}'`], level: "error" }), {};
  }
});
function ee(s) {
  var e;
  (e = N.Logger.getInstance(s)) == null || e.processMessage(s);
}
__name(ee, "ee");
const Kt = Qt;
var Xt = Kt;
const d = /* @__PURE__ */ ce(Xt);
var Zt = /* @__PURE__ */ ((s) => (s.PENDING = "pending", s.IN_PROGRESS = "in_progress", s.COMPLETED = "completed", s.PAUSED = "paused", s.ERROR = "error", s.CANCELLED = "cancelled", s))(Zt || {});
const m = class m2 {
  static {
    __name(this, "m2");
  }
  constructor(e, t) {
    l(this, "downloads");
    l(this, "mainWindow");
    l(this, "modelsDirectory");
    this.downloads = /* @__PURE__ */ new Map(), this.mainWindow = e, this.modelsDirectory = t, electron.session.defaultSession.on("will-download", (r, n, o) => {
      const i = n.getURLChain()[0];
      d.info("Will-download event ", i);
      const a = this.downloads.get(i);
      a && (this.reportProgress({
        url: i,
        filename: a.filename,
        savePath: a.savePath,
        progress: 0,
        status: "pending"
        /* PENDING */
      }), n.setSavePath(a.tempPath), a.item = n, d.info(`Setting save path to ${n.getSavePath()}`), n.on("updated", (h, c) => {
        if (c === "interrupted")
          d.info("Download is interrupted but can be resumed");
        else if (c === "progressing") {
          const p = n.getReceivedBytes() / n.getTotalBytes();
          n.isPaused() ? (d.info("Download is paused"), this.reportProgress({
            url: i,
            progress: p,
            filename: a.filename,
            savePath: a.savePath,
            status: "paused"
            /* PAUSED */
          })) : this.reportProgress({
            url: i,
            progress: p,
            filename: a.filename,
            savePath: a.savePath,
            status: "in_progress"
            /* IN_PROGRESS */
          });
        }
      }), n.once("done", (h, c) => {
        if (c === "completed") {
          try {
            (void 0)(a.tempPath, a.savePath), d.info(`Successfully renamed ${a.tempPath} to ${a.savePath}`);
          } catch (p) {
            d.error(`Failed to rename downloaded file: ${p}. Deleting temp file.`), (void 0)(a.tempPath);
          }
          this.reportProgress({
            url: i,
            filename: a.filename,
            savePath: a.savePath,
            progress: 1,
            status: "completed"
            /* COMPLETED */
          }), this.downloads.delete(i);
        } else {
          d.info(`Download failed: ${c}`);
          const p = n.getReceivedBytes() / n.getTotalBytes();
          this.reportProgress({
            url: i,
            filename: a.filename,
            progress: p,
            status: "error",
            savePath: a.savePath
          });
        }
      }));
    });
  }
  startDownload(e, t, r) {
    const n = this.getLocalSavePath(r, t);
    if (!this.isPathInModelsDirectory(n))
      return d.error(`Save path ${n} is not in models directory ${this.modelsDirectory}`), this.reportProgress({
        url: e,
        savePath: t,
        filename: r,
        progress: 0,
        status: "error",
        message: "Save path is not in models directory"
      }), false;
    const o = this.validateSafetensorsFile(e, r);
    if (!o.isValid)
      return d.error(o.error), this.reportProgress({
        url: e,
        savePath: t,
        filename: r,
        progress: 0,
        status: "error",
        message: o.error
      }), false;
    (void 0)(n);
    const i = this.downloads.get(e);
    if (i)
      return d.info("Download already exists"), i.item && i.item.isPaused() && this.resumeDownload(e), true;
    d.info(`Starting download ${e} to ${n}`);
    const a = this.getTempPath(r, t);
    return this.downloads.set(e, { url: e, savePath: n, tempPath: a, filename: r, item: null }), electron.session.defaultSession.downloadURL(e), true;
  }
  cancelDownload(e) {
    const t = this.downloads.get(e);
    t && t.item && (d.info("Cancelling download"), t.item.cancel(), this.downloads.delete(e));
  }
  pauseDownload(e) {
    const t = this.downloads.get(e);
    t && t.item && (d.info("Pausing download"), t.item.pause());
  }
  resumeDownload(e) {
    const t = this.downloads.get(e);
    t && (t.item && t.item.canResume() ? (d.info("Resuming download"), t.item.resume()) : this.startDownload(t.url, t.savePath, t.filename));
  }
  deleteModel(e, t) {
    const r = this.getLocalSavePath(e, t);
    if (!this.isPathInModelsDirectory(r))
      return d.error(`Save path ${r} is not in models directory ${this.modelsDirectory}`), false;
    const n = this.getTempPath(e, t);
    try {
      (void 0)(r);
    } catch (o) {
      d.error(`Failed to delete file ${r}: ${o}`);
    }
    try {
      (void 0)(n);
    } catch (o) {
      d.error(`Failed to delete file ${n}: ${o}`);
    }
    return true;
  }
  getAllDownloads() {
    return Array.from(this.downloads.values()).filter((e) => e.item !== null).map((e) => {
      var t, r, n, o;
      return {
        url: e.url,
        filename: e.filename,
        tempPath: e.tempPath,
        state: this.convertDownloadState((t = e.item) == null ? void 0 : t.getState()),
        receivedBytes: ((r = e.item) == null ? void 0 : r.getReceivedBytes()) || 0,
        totalBytes: ((n = e.item) == null ? void 0 : n.getTotalBytes()) || 0,
        isPaused: ((o = e.item) == null ? void 0 : o.isPaused()) || false
      };
    });
  }
  convertDownloadState(e) {
    switch (e) {
      case "progressing":
        return "in_progress";
      case "completed":
        return "completed";
      case "cancelled":
        return "cancelled";
      case "interrupted":
        return "error";
      default:
        return "error";
    }
  }
  getTempPath(e, t) {
    return (void 0)(this.modelsDirectory, t, `Unconfirmed ${e}.tmp`);
  }
  // Only allow .safetensors files to be downloaded.
  validateSafetensorsFile(e, t) {
    try {
      return !new URL(e).pathname.toLowerCase().endsWith(".safetensors") && !t.toLowerCase().endsWith(".safetensors") ? {
        isValid: false,
        error: "Invalid file type: must be a .safetensors file"
      } : { isValid: true };
    } catch (r) {
      return {
        isValid: false,
        error: `Invalid URL format: ${r}`
      };
    }
  }
  getLocalSavePath(e, t) {
    return (void 0)(this.modelsDirectory, t, e);
  }
  isPathInModelsDirectory(e) {
    const t = (void 0)(e), r = (void 0)(this.modelsDirectory);
    return t.startsWith(r);
  }
  reportProgress({
    url: e,
    progress: t,
    status: r,
    savePath: n,
    filename: o,
    message: i = ""
  }) {
    d.info(`Download progress [${o}]: ${t}, status: ${r}, message: ${i}`), this.mainWindow.send(E.DOWNLOAD_PROGRESS, {
      url: e,
      progress: t,
      status: r,
      message: i,
      savePath: n,
      filename: o
    });
  }
  static getInstance(e, t) {
    return m2.instance || (m2.instance = new m2(e, t), m2.instance.registerIpcHandlers()), m2.instance;
  }
  registerIpcHandlers() {
    electron.ipcMain.handle(
      E.START_DOWNLOAD,
      (e, { url: t, path: r, filename: n }) => this.startDownload(t, r, n)
    ), electron.ipcMain.handle(E.PAUSE_DOWNLOAD, (e, t) => this.pauseDownload(t)), electron.ipcMain.handle(E.RESUME_DOWNLOAD, (e, t) => this.resumeDownload(t)), electron.ipcMain.handle(E.CANCEL_DOWNLOAD, (e, t) => this.cancelDownload(t)), electron.ipcMain.handle(E.GET_ALL_DOWNLOADS, (e) => this.getAllDownloads()), electron.ipcMain.handle(E.DELETE_MODEL, (e, { filename: t, path: r }) => this.deleteModel(t, r));
  }
};
l(m, "instance");
let G = m;
export {
  or as a,
  oe as o,
  rr as r
};
//# sourceMappingURL=index-Ba5g1c58.js.map