electron-incremental-update 2.0.0 → 2.1.0

package/README.md

@@ -340,7 +340,8 @@ electronWithUpdater({
 
 https://electron-vite.org/guide/source-code-protection
 
-- Improve the string protection (see [original issue](https://github.com/alex8088/electron-vite/issues/552)) and protect all strings by default
+- Improve the string protection (see [original issue](https://github.com/alex8088/electron-vite/issues/552))
+- Protect all strings by default
 - Minification is allowed
 
 #### Limitation
@@ -669,6 +670,24 @@ export interface ElectronUpdaterOptions {
   overrideGenerator?: GeneratorOverrideFunctions
 }
 
+export interface BytecodeOptions {
+  enable: boolean
+  /**
+   * Enable in preload script. Remember to set `sandbox: false` when creating window
+   */
+  preload?: boolean
+  /**
+   * Custom electron binary path
+   */
+  electronPath?: string
+  /**
+   * Before transformed code compile function. If return `Falsy` value, it will be ignored
+   * @param code transformed code
+   * @param id file path
+   */
+  beforeCompile?: (code: string, id: string) => Promisable<string | null | undefined | void>
+}
+
 export interface BuildEntryOption {
   /**
    * Override to minify on entry

package/dist/bytecode-I4PMYUGT.js

@@ -0,0 +1,166 @@
+import { readableSize } from './chunk-WYQ5DRO7.js';
+import { convertLiteral, bytecodeModuleLoader, convertArrowFunctionAndTemplate, compileToBytecode, useStrict, toRelativePath } from './chunk-AUY7A2FL.js';
+import './chunk-7M7DIMDN.js';
+import { bytecodeLog, bytecodeId } from './chunk-5NKEXGI3.js';
+import { bytecodeModuleLoaderCode } from './chunk-7IRGAAL2.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { createFilter, normalizePath } from 'vite';
+import MagicString from 'magic-string';
+
+function bytecodePlugin(env, options) {
+  const {
+    enable,
+    preload = false,
+    electronPath,
+    beforeCompile
+  } = options;
+  if (!enable) {
+    return null;
+  }
+  if (!preload && env === "preload") {
+    bytecodeLog.warn('`bytecodePlugin` is skiped in preload. To enable in preload, please manually set the "enablePreload" option to true and set `sandbox: false` when creating the window', { timestamp: true });
+    return null;
+  }
+  const filter = createFilter(/\.(m?[jt]s|[jt]sx)$/);
+  let config;
+  let bytecodeRequired = false;
+  let bytecodeFiles = [];
+  return {
+    name: `${bytecodeId}-${env}`,
+    apply: "build",
+    enforce: "post",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    transform(code, id) {
+      if (!filter(id)) {
+        return convertLiteral(code, !!config.build.sourcemap);
+      }
+    },
+    generateBundle(options2) {
+      if (options2.format !== "es" && bytecodeRequired) {
+        this.emitFile({
+          type: "asset",
+          source: `${bytecodeModuleLoaderCode}
+`,
+          name: "Bytecode Loader File",
+          fileName: bytecodeModuleLoader
+        });
+      }
+    },
+    renderChunk(code, chunk, options2) {
+      if (options2.format === "es") {
+        bytecodeLog.warn(
+          '`bytecodePlugin` does not support ES module, please set "build.rollupOptions.output.format" option to "cjs"',
+          { timestamp: true }
+        );
+        return null;
+      }
+      if (chunk.type === "chunk") {
+        bytecodeRequired = true;
+        return convertArrowFunctionAndTemplate(code);
+      }
+      return null;
+    },
+    async writeBundle(options2, output) {
+      if (options2.format === "es" || !bytecodeRequired) {
+        return;
+      }
+      const outDir = options2.dir;
+      bytecodeFiles = [];
+      const bundles = Object.keys(output);
+      const chunks = Object.values(output).filter(
+        (chunk) => chunk.type === "chunk" && chunk.fileName !== bytecodeModuleLoader
+      );
+      const bytecodeChunks = chunks.map((chunk) => chunk.fileName);
+      const nonEntryChunks = chunks.filter((chunk) => !chunk.isEntry).map((chunk) => path.basename(chunk.fileName));
+      const pattern = nonEntryChunks.map((chunk) => `(${chunk})`).join("|");
+      const bytecodeRE = pattern ? new RegExp(`require\\(\\S*(?=(${pattern})\\S*\\))`, "g") : null;
+      const getBytecodeLoaderBlock = (chunkFileName) => {
+        return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`;
+      };
+      await Promise.all(
+        bundles.map(async (name) => {
+          const chunk = output[name];
+          if (chunk.type === "chunk") {
+            let _code = chunk.code;
+            const chunkFilePath = path.resolve(outDir, name);
+            if (beforeCompile) {
+              const cbResult = await beforeCompile(_code, chunkFilePath);
+              if (cbResult) {
+                _code = cbResult;
+              }
+            }
+            if (bytecodeRE && _code.match(bytecodeRE)) {
+              let match;
+              const s = new MagicString(_code);
+              while (match = bytecodeRE.exec(_code)) {
+                const [prefix, chunkName] = match;
+                const len = prefix.length + chunkName.length;
+                s.overwrite(match.index, match.index + len, `${prefix + chunkName}c`, {
+                  contentOnly: true
+                });
+              }
+              _code = s.toString();
+            }
+            if (bytecodeChunks.includes(name)) {
+              const bytecodeBuffer = await compileToBytecode(_code, electronPath);
+              fs.writeFileSync(`${chunkFilePath}c`, bytecodeBuffer);
+              if (chunk.isEntry) {
+                const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+                const bytecodeModuleBlock = `require("./${`${path.basename(name)}c`}");`;
+                const code = `${useStrict}
+${bytecodeLoaderBlock}
+module.exports=${bytecodeModuleBlock}
+`;
+                fs.writeFileSync(chunkFilePath, code);
+              } else {
+                fs.unlinkSync(chunkFilePath);
+              }
+              bytecodeFiles.push({ name: `${name}c`, size: bytecodeBuffer.length });
+            } else {
+              if (chunk.isEntry) {
+                let hasBytecodeMoudle = false;
+                const idsToHandle = /* @__PURE__ */ new Set([...chunk.imports, ...chunk.dynamicImports]);
+                for (const moduleId of idsToHandle) {
+                  if (bytecodeChunks.includes(moduleId)) {
+                    hasBytecodeMoudle = true;
+                    break;
+                  }
+                  const moduleInfo = this.getModuleInfo(moduleId);
+                  if (moduleInfo && !moduleInfo.isExternal) {
+                    const { importers, dynamicImporters } = moduleInfo;
+                    for (const importerId of importers) {
+                      idsToHandle.add(importerId);
+                    }
+                    for (const importerId of dynamicImporters) {
+                      idsToHandle.add(importerId);
+                    }
+                  }
+                }
+                const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+                _code = hasBytecodeMoudle ? _code.replace(useStrict, `${useStrict}
+${bytecodeLoaderBlock}`) : _code;
+              }
+              fs.writeFileSync(chunkFilePath, _code);
+            }
+          }
+        })
+      );
+    },
+    closeBundle() {
+      const outDir = `${normalizePath(path.relative(config.root, path.resolve(config.root, config.build.outDir)))}/`;
+      bytecodeFiles.forEach((file) => {
+        bytecodeLog.info(
+          `${outDir}${file.name} [${readableSize(file.size)}]`,
+          { timestamp: true }
+        );
+      });
+      bytecodeLog.info(`${bytecodeFiles.length} bundles compiled into bytecode.`, { timestamp: true });
+      bytecodeFiles = [];
+    }
+  };
+}
+
+export { bytecodePlugin };

package/dist/chunk-5CE27A6G.js

@@ -0,0 +1,44 @@
+import { electronMajorVersion } from './chunk-AUY7A2FL.js';
+import MagicString from 'magic-string';
+
+// src/vite/esm/constant.ts
+var CJSShim = `
+// -- CommonJS Shims --
+import __cjs_url__ from 'node:url';
+import __cjs_path__ from 'node:path';
+import __cjs_mod__ from 'node:module';
+const __filename = __cjs_url__.fileURLToPath(import.meta.url);
+const __dirname = __cjs_path__.dirname(__filename);
+const require = __cjs_mod__.createRequire(import.meta.url);
+`;
+var CJSShim_electron_30 = `
+// -- CommonJS Shims --
+import __cjs_mod__ from 'node:module';
+const __filename = import.meta.filename;
+const __dirname = import.meta.dirname;
+const require = __cjs_mod__.createRequire(import.meta.url);
+`;
+var shim = electronMajorVersion >= 30 ? CJSShim_electron_30 : CJSShim;
+
+// src/vite/esm/utils.ts
+var ESMStaticImportRe = /(?<=\s|^|;)import\s*([\s"']*(?<imports>[\p{L}\p{M}\w\t\n\r $*,/{}@.]+)from\s*)?["']\s*(?<specifier>(?<=")[^"]*[^\s"](?=\s*")|(?<=')[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gmu;
+function findStaticImports(code) {
+  const matches = [];
+  for (const match of code.matchAll(ESMStaticImportRe)) {
+    matches.push({ end: (match.index || 0) + match[0].length });
+  }
+  return matches;
+}
+function insertCJSShim(code, sourcemap, insertPosition = 0) {
+  if (code.includes(shim) || !/__filename|__dirname|require\(|require\.resolve\(|require\.apply\(/.test(code)) {
+    return null;
+  }
+  const s = new MagicString(code);
+  s.appendRight(insertPosition, shim);
+  return {
+    code: s.toString(),
+    map: sourcemap ? s.generateMap({ hires: "boundary" }) : null
+  };
+}
+
+export { findStaticImports, insertCJSShim };

package/dist/chunk-5NKEXGI3.js

@@ -0,0 +1,10 @@
+import { createLogger } from 'vite';
+
+// src/vite/constant.ts
+var id = "electron-incremental-updater";
+var bytecodeId = `${id}-bytecode`;
+var esmId = `${id}-esm`;
+var log = createLogger("info", { prefix: `[${id}]` });
+var bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
+
+export { bytecodeId, bytecodeLog, esmId, id, log };

package/dist/chunk-7IRGAAL2.js

@@ -0,0 +1,5 @@
+// src/vite/bytecode/code.ts
+var bytecodeGeneratorScript = "const vm = require('vm')\nconst v8 = require('v8')\nconst wrap = require('module').wrap\nv8.setFlagsFromString('--no-lazy')\nv8.setFlagsFromString('--no-flush-bytecode')\nlet code = ''\nprocess.stdin.setEncoding('utf-8')\nprocess.stdin.on('readable', () => {\n  const data = process.stdin.read()\n  if (data !== null) {\n    code += data\n  }\n})\nprocess.stdin.on('end', () => {\n  try {\n    if (typeof code !== 'string') {\n      throw new Error('javascript code must be string.')\n    }\n    const script = new vm.Script(wrap(code), { produceCachedData: true })\n    const bytecodeBuffer = script.createCachedData()\n    process.stdout.write(bytecodeBuffer)\n  } catch (error) {\n    console.error(error)\n  }\n})\n";
+var bytecodeModuleLoaderCode = '"use strict";\nconst fs = require("fs");\nconst path = require("path");\nconst vm = require("vm");\nconst v8 = require("v8");\nconst Module = require("module");\nv8.setFlagsFromString("--no-lazy");\nv8.setFlagsFromString("--no-flush-bytecode");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script("", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error("BytecodeBuffer must be a buffer object.");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = "";\n  if (length > 1) {\n    dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error("Invalid or incompatible cached data (cachedDataRejected)");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n';
+
+export { bytecodeGeneratorScript, bytecodeModuleLoaderCode };

package/dist/chunk-7M7DIMDN.js

@@ -0,0 +1,43 @@
+// src/utils/version.ts
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
+  if (!match) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  const ret = {
+    major,
+    minor,
+    patch,
+    stage: "",
+    stageVersion: -1
+  };
+  if (match[4]) {
+    let [stage, _v] = match[4].split(".");
+    ret.stage = stage;
+    ret.stageVersion = Number(_v) || -1;
+  }
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`Invalid version: ${version}`);
+  }
+  return ret;
+}
+function isUpdateJSON(json) {
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
+  return is(json) && is(json?.beta);
+}
+function defaultVersionJsonGenerator(existingJson, signature, version, minimumVersion) {
+  existingJson.beta = {
+    version,
+    minimumVersion,
+    signature
+  };
+  if (!parseVersion(version).stage) {
+    existingJson.version = version;
+    existingJson.minimumVersion = minimumVersion;
+    existingJson.signature = signature;
+  }
+  return existingJson;
+}
+
+export { defaultVersionJsonGenerator, isUpdateJSON, parseVersion };

package/dist/chunk-AUY7A2FL.js

@@ -0,0 +1,147 @@
+import { parseVersion } from './chunk-7M7DIMDN.js';
+import { bytecodeLog } from './chunk-5NKEXGI3.js';
+import { bytecodeGeneratorScript } from './chunk-7IRGAAL2.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import cp from 'node:child_process';
+import * as babel from '@babel/core';
+import MagicString from 'magic-string';
+import { getPackageInfoSync } from 'local-pkg';
+
+var electronModule = getPackageInfoSync("electron");
+var electronMajorVersion = parseVersion(electronModule.version).major;
+var useStrict = "'use strict';";
+var bytecodeModuleLoader = "__loader__.js";
+function getElectronPath() {
+  const electronModulePath = electronModule.rootPath;
+  let electronExecPath = process.env.ELECTRON_EXEC_PATH || "";
+  if (!electronExecPath) {
+    if (!electronModulePath) {
+      throw new Error("Electron is not installed");
+    }
+    const pathFile = path.join(electronModulePath, "path.txt");
+    let executablePath;
+    if (fs.existsSync(pathFile)) {
+      executablePath = fs.readFileSync(pathFile, "utf-8");
+    }
+    if (executablePath) {
+      electronExecPath = path.join(electronModulePath, "dist", executablePath);
+      process.env.ELECTRON_EXEC_PATH = electronExecPath;
+    } else {
+      throw new Error("Electron executable file is not existed");
+    }
+  }
+  return electronExecPath;
+}
+function getBytecodeCompilerPath() {
+  const scriptPath = path.join(electronModule.rootPath, "EIU_bytenode.cjs");
+  if (!fs.existsSync(scriptPath)) {
+    fs.writeFileSync(scriptPath, bytecodeGeneratorScript);
+  }
+  return scriptPath;
+}
+function toRelativePath(filename, importer) {
+  const relPath = path.posix.relative(path.dirname(importer), filename);
+  return relPath.startsWith(".") ? relPath : `./${relPath}`;
+}
+function compileToBytecode(code, electronPath = getElectronPath()) {
+  let data = Buffer.from([]);
+  const logErr = (...args) => bytecodeLog.error(args.join(" "), { timestamp: true });
+  const bytecodePath = getBytecodeCompilerPath();
+  return new Promise((resolve, reject) => {
+    const proc = cp.spawn(electronPath, [bytecodePath], {
+      env: { ELECTRON_RUN_AS_NODE: "1" },
+      stdio: ["pipe", "pipe", "pipe", "ipc"]
+    });
+    if (proc.stdin) {
+      proc.stdin.write(code);
+      proc.stdin.end();
+    }
+    if (proc.stdout) {
+      proc.stdout.on("data", (chunk) => data = Buffer.concat([data, chunk]));
+      proc.stdout.on("error", (err) => logErr(err));
+      proc.stdout.on("end", () => resolve(data));
+    }
+    if (proc.stderr) {
+      proc.stderr.on("data", (chunk) => logErr("Error: ", chunk.toString()));
+      proc.stderr.on("error", (err) => logErr("Error: ", err));
+    }
+    proc.addListener("error", (err) => logErr(err));
+    proc.on("error", (err) => reject(err));
+    proc.on("exit", () => resolve(data));
+  });
+}
+function convertArrowFunctionAndTemplate(code) {
+  const result = babel.transform(code, {
+    plugins: ["@babel/plugin-transform-arrow-functions", "@babel/plugin-transform-template-literals"]
+  });
+  return {
+    code: result?.code || code,
+    map: result?.map
+  };
+}
+var decodeFn = ";function _0xstr_(a,b){return String.fromCharCode.apply(0,a.map(function(x){return x-b}))};";
+function obfuscateString(input, offset = ~~(Math.random() * 16) + 1) {
+  const hexArray = input.split("").map((c) => `0x${(c.charCodeAt(0) + offset).toString(16)}`);
+  return `_0xstr_([${hexArray.join(",")}],${offset})`;
+}
+function convertLiteral(code, sourcemap, offset) {
+  const s = new MagicString(code);
+  let hasTransformed = false;
+  const ast = babel.parse(code, { ast: true });
+  if (!ast) {
+    throw new Error("Cannot parse code");
+  }
+  babel.traverse(ast, {
+    StringLiteral(path2) {
+      const parent = path2.parent;
+      const node = path2.node;
+      if (parent.type === "CallExpression") {
+        if (parent.callee.type === "Identifier" && parent.callee.name === "require") {
+          return;
+        }
+        if (parent.callee.type === "Import") {
+          return;
+        }
+      }
+      if (parent.type.startsWith("Export")) {
+        return;
+      }
+      if (parent.type.startsWith("Import")) {
+        return;
+      }
+      if (parent.type === "ObjectMethod" && parent.key === node) {
+        return;
+      }
+      if (parent.type === "ObjectProperty" && parent.key === node) {
+        const result2 = `[${obfuscateString(node.value, offset)}]`;
+        const start2 = node.start;
+        const end2 = node.end;
+        if (start2 && end2) {
+          s.overwrite(start2, end2, result2);
+          hasTransformed = true;
+        }
+        return;
+      }
+      if (!node.value.trim()) {
+        return;
+      }
+      const result = obfuscateString(node.value, offset);
+      const start = node.start;
+      const end = node.end;
+      if (start && end) {
+        s.overwrite(start, end, result);
+        hasTransformed = true;
+      }
+    }
+  });
+  if (hasTransformed) {
+    s.append("\n").append(decodeFn);
+  }
+  return {
+    code: s.toString(),
+    map: sourcemap ? s.generateMap({ hires: true }) : void 0
+  };
+}
+
+export { bytecodeModuleLoader, compileToBytecode, convertArrowFunctionAndTemplate, convertLiteral, decodeFn, electronMajorVersion, electronModule, obfuscateString, toRelativePath, useStrict };

package/dist/chunk-WYQ5DRO7.js

@@ -0,0 +1,12 @@
+// src/vite/utils.ts
+function readableSize(size) {
+  const units = ["B", "KB", "MB", "GB"];
+  let i = 0;
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024;
+    i++;
+  }
+  return `${size.toFixed(2)} ${units[i]}`;
+}
+
+export { readableSize };

package/dist/chunk-ZM5CIZ4L.js

@@ -0,0 +1,106 @@
+import { __require } from './chunk-RCRKUKFX.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import electron from 'electron';
+
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
+}
+function getAppVersion() {
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return electron.app.getVersion();
+}
+function requireNative(moduleName) {
+  const m = getPathFromEntryAsar(moduleName);
+  if (__EIU_IS_ESM__) {
+    throw new Error(`Cannot require "${m}", \`requireNative\` only support CommonJS, use \`importNative\` instead`);
+  }
+  return __require(m);
+}
+async function importNative(moduleName) {
+  const m = getPathFromEntryAsar(moduleName);
+  if (!__EIU_IS_ESM__) {
+    throw new Error(`Cannot import "${m}", \`importNative\` only support ESModule, use \`requireNative\` instead`);
+  }
+  return await import(`file://${m}.js`);
+}
+function restartApp() {
+  electron.app.relaunch();
+  electron.app.quit();
+}
+function setAppUserModelId(id) {
+  if (isWin) {
+    electron.app.setAppUserModelId(id ?? `org.${electron.app.name}`);
+  }
+}
+function disableHWAccForWin7() {
+  if (!__EIU_IS_ESM__ && __require("node:os").release().startsWith("6.1")) {
+    electron.app.disableHardwareAcceleration();
+  }
+}
+function singleInstance(window) {
+  const result = electron.app.requestSingleInstanceLock();
+  if (result) {
+    electron.app.on("second-instance", () => {
+      if (window) {
+        window.show();
+        if (window.isMinimized()) {
+          window.restore();
+        }
+        window.focus();
+      }
+    });
+  } else {
+    electron.app.quit();
+  }
+  return result;
+}
+function setPortableAppDataPath(dirName = "data") {
+  const portablePath = path.join(path.dirname(electron.app.getPath("exe")), dirName);
+  if (!fs.existsSync(portablePath)) {
+    fs.mkdirSync(portablePath);
+  }
+  electron.app.setPath("appData", portablePath);
+}
+function loadPage(win, htmlFilePath = "index.html") {
+  if (isDev) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath);
+  } else {
+    win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+  }
+}
+function beautifyDevTools(win, options) {
+  const { mono, sans, scrollbar = true } = options;
+  win.webContents.on("devtools-opened", () => {
+    let css = `:root{--sans: ${sans};--mono: ${mono}}:root,body{--source-code-font-family: var(--mono) !important;--source-code-font-size: 12px !important;--monospace-font-family: var(--mono) !important;--monospace-font-size: 12px !important;--default-font-family: var(--sans), sans-serif !important;--default-font-size: 12px !important}button,input,select,.undisplayable-text,.expandable-inline-button{font-family:var(--sans)!important}`;
+    if (scrollbar) {
+      css += ":root{--scrollbar-width: max(.85vw, 10px)}@media (prefers-color-scheme: light){:root{--scrollbar-color-rgb: 0, 0, 0}}@media (prefers-color-scheme: dark){:root{--scrollbar-color-rgb: 255, 255, 255}}*::-webkit-scrollbar{width:var(--scrollbar-width)!important;height:var(--scrollbar-width)!important}*::-webkit-scrollbar-track{background-color:transparent!important;border-radius:var(--scrollbar-width)!important;box-shadow:none!important}*::-webkit-scrollbar-thumb{box-shadow:inset 0 0 0 var(--scrollbar-width)!important;border-radius:var(--scrollbar-width)!important;border:calc(var(--scrollbar-width) * 2 / 9) solid transparent!important;background-clip:content-box;background-color:transparent!important;color:rgba(var(--scrollbar-color-rgb),30%)!important}*::-webkit-scrollbar-thumb:hover{color:rgba(var(--scrollbar-color-rgb),45%)!important}*::-webkit-scrollbar-thumb:active{color:rgba(var(--scrollbar-color-rgb),60%)!important}@supports not selector(::-webkit-scrollbar){html{scrollbar-color:rgb(var(--scrollbar-color-rgb));scrollbar-width:thin}}";
+    }
+    const js = `let overriddenStyle=document.createElement('style');overriddenStyle.innerHTML='${css}';document.body.append(overriddenStyle);document.body.classList.remove('platform-windows','platform-mac','platform-linux');`;
+    win?.webContents.devToolsWebContents?.executeJavaScript(js);
+  });
+}
+function getPathFromMain(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "main", ...paths) : getPathFromAppNameAsar("main", ...paths);
+}
+function getPathFromPreload(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? path.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+}
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+
+export { beautifyDevTools, disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromMain, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, importNative, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/code-P5OANH3Q.js

@@ -0,0 +1 @@
+export { bytecodeGeneratorScript, bytecodeModuleLoaderCode } from './chunk-7IRGAAL2.js';

package/dist/constant-ME27JB5D.js

@@ -0,0 +1 @@
+export { bytecodeId, bytecodeLog, esmId, id, log } from './chunk-5NKEXGI3.js';

package/dist/esm-ZFXJ56BN.js

@@ -0,0 +1,26 @@
+import { findStaticImports, insertCJSShim } from './chunk-5CE27A6G.js';
+import './chunk-AUY7A2FL.js';
+import './chunk-7M7DIMDN.js';
+import { esmId } from './chunk-5NKEXGI3.js';
+import './chunk-7IRGAAL2.js';
+
+// src/vite/esm/index.ts
+function esm() {
+  let sourcemap;
+  return {
+    name: esmId,
+    enforce: "post",
+    configResolved(config) {
+      sourcemap = config.build.sourcemap;
+    },
+    renderChunk(code, _chunk, options) {
+      if (options.format === "es") {
+        const lastESMImport = findStaticImports(code).pop();
+        const pos = lastESMImport ? lastESMImport.end : 0;
+        return insertCJSShim(code, sourcemap, pos);
+      }
+    }
+  };
+}
+
+export { esm };