electron-incremental-update 2.3.3 → 2.3.5

package/README.md

@@ -920,7 +920,9 @@ export interface BuildEntryOption {
    */
   ignoreDynamicRequires?: boolean
   /**
-   * `external` option in `build.rollupOptions`, default is node built-in modules or native modules
+   * `external` option in `build.rollupOptions`,
+   * default is node built-in modules or native modules.
+   * If is in dev, also external `dependencies` in package.json
    */
   external?: NonNullable<NonNullable<InlineConfig['build']>['rollupOptions']>['external']
   /**

package/dist/vite.d.ts

@@ -104,7 +104,9 @@ interface BuildEntryOption {
      */
     ignoreDynamicRequires?: boolean;
     /**
-     * `external` option in `build.rollupOptions`, default is node built-in modules or native modules
+     * `external` option in `build.rollupOptions`,
+     * default is node built-in modules or native modules.
+     * If is in dev, also external `dependencies` in package.json
      */
     external?: NonNullable<NonNullable<InlineConfig['build']>['rollupOptions']>['external'];
     /**
@@ -322,7 +324,7 @@ declare const debugStartup: StartupFn;
  *     startup: args => filterErrorMessageStartup(
  *       args,
  *       // ignore error message when function returns false
- *       msg => !/"code":-32601/.test(message)
+ *       msg => !/"code":-32601/.test(msg)
  *     )
  *   },
  * })

package/dist/vite.js

@@ -1,23 +1,447 @@
-import { copyAndSkipIfExist, readableSize } from './chunk-TPTWE33H.js';
-import { defaultVersionJsonGenerator, isUpdateJSON } from './chunk-LR7LR5WG.js';
-export { convertLiteral } from './chunk-LR7LR5WG.js';
-import { log, id } from './chunk-5NKEXGI3.js';
-import fs2 from 'node:fs';
-import path3 from 'node:path';
+import fs5 from 'node:fs';
+import path5 from 'node:path';
 import { isCI } from 'ci-info';
 export { isCI } from 'ci-info';
-import { loadPackageJSON, getPackageInfoSync } from 'local-pkg';
+import { getPackageInfoSync, loadPackageJSON } from 'local-pkg';
 export { getPackageInfo, getPackageInfoSync, loadPackageJSON, resolveModule } from 'local-pkg';
-import { normalizePath, mergeConfig } from 'vite';
+import { createLogger, normalizePath, mergeConfig, createFilter } from 'vite';
 import { startup, build } from 'vite-plugin-electron';
 import { notBundle } from 'vite-plugin-electron/plugin';
 import ElectronSimple from 'vite-plugin-electron/simple';
 import Asar from '@electron/asar';
+import MagicString from 'magic-string';
+import cp from 'node:child_process';
+import * as babel from '@babel/core';
 import { builtinModules } from 'node:module';
 import crypto from 'node:crypto';
 import zlib from 'node:zlib';
 import { generate } from 'selfsigned';
 
+// src/vite/index.ts
+
+// 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;
+}
+var is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
+function isUpdateJSON(json) {
+  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;
+}
+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}]` });
+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]}`;
+}
+function copyAndSkipIfExist(from, to, skipIfExist) {
+  if (!skipIfExist || !fs5.existsSync(to)) {
+    try {
+      fs5.cpSync(from, to, { recursive: true });
+    } catch (error) {
+      log.warn(`Copy failed: ${error}`, { timestamp: true });
+    }
+  }
+}
+
+// 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';
+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 = path5.join(electronModulePath, "path.txt");
+    let executablePath;
+    if (fs5.existsSync(pathFile)) {
+      executablePath = fs5.readFileSync(pathFile, "utf-8");
+    }
+    if (executablePath) {
+      electronExecPath = path5.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 = path5.join(electronModule.rootPath, "EIU_bytenode.cjs");
+  if (!fs5.existsSync(scriptPath)) {
+    fs5.writeFileSync(scriptPath, bytecodeGeneratorScript);
+  }
+  return scriptPath;
+}
+function toRelativePath(filename, importer) {
+  const relPath = path5.posix.relative(path5.dirname(importer), filename);
+  return relPath.startsWith(".") ? relPath : `./${relPath}`;
+}
+var logErr = (...args) => bytecodeLog.error(args.join(" "), { timestamp: true });
+function compileToBytecode(code, electronPath = getElectronPath()) {
+  let data = Buffer.from([]);
+  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(path6) {
+      const parent = path6.parent;
+      const node = path6.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
+  };
+}
+
+// src/vite/bytecode/index.ts
+function getBytecodeLoaderBlock(chunkFileName) {
+  return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`;
+}
+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, id2) {
+      if (!filter(id2)) {
+        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) => path5.basename(chunk.fileName));
+      const pattern = nonEntryChunks.map((chunk) => `(${chunk})`).join("|");
+      const bytecodeRE = pattern ? new RegExp(`require\\(\\S*(?=(${pattern})\\S*\\))`, "g") : null;
+      await Promise.all(
+        bundles.map(async (name) => {
+          const chunk = output[name];
+          if (chunk.type === "chunk") {
+            let _code = chunk.code;
+            const chunkFilePath = path5.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);
+              fs5.writeFileSync(`${chunkFilePath}c`, bytecodeBuffer);
+              if (chunk.isEntry) {
+                const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+                const bytecodeModuleBlock = `require("./${`${path5.basename(name)}c`}");`;
+                const code = `${useStrict}
+${bytecodeLoaderBlock}
+module.exports=${bytecodeModuleBlock}
+`;
+                fs5.writeFileSync(chunkFilePath, code);
+              } else {
+                fs5.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(
+                  new RegExp(`(${useStrict})|("use strict";)`),
+                  `${useStrict}
+${bytecodeLoaderBlock}`
+                ) : _code;
+              }
+              fs5.writeFileSync(chunkFilePath, _code);
+            }
+          }
+        })
+      );
+    },
+    closeBundle() {
+      const outDir = `${normalizePath(path5.relative(config.root, path5.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 = [];
+    }
+  };
+}
+
+// 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
+  };
+}
+
+// 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);
+      }
+    }
+  };
+}
+
+// src/vite/build.ts
 async function buildAsar({
   version,
   asarOutputPath,
@@ -26,11 +450,11 @@ async function buildAsar({
   rendererDistPath,
   generateGzipFile
 }) {
-  fs2.renameSync(rendererDistPath, path3.join(electronDistPath, "renderer"));
-  fs2.writeFileSync(path3.join(electronDistPath, "version"), version);
+  fs5.renameSync(rendererDistPath, path5.join(electronDistPath, "renderer"));
+  fs5.writeFileSync(path5.join(electronDistPath, "version"), version);
   await Asar.createPackage(electronDistPath, asarOutputPath);
-  const buf = await generateGzipFile(fs2.readFileSync(asarOutputPath));
-  fs2.writeFileSync(gzipPath, buf);
+  const buf = await generateGzipFile(fs5.readFileSync(asarOutputPath));
+  fs5.writeFileSync(gzipPath, buf);
   log.info(`Build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
   return buf;
 }
@@ -53,9 +477,9 @@ async function buildUpdateJson({
     signature: "",
     version
   };
-  if (fs2.existsSync(versionPath)) {
+  if (fs5.existsSync(versionPath)) {
     try {
-      const oldVersionJson = JSON.parse(fs2.readFileSync(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(fs5.readFileSync(versionPath, "utf-8"));
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
@@ -69,7 +493,7 @@ async function buildUpdateJson({
   if (!isUpdateJSON(_json)) {
     throw new Error("Invalid update json");
   }
-  fs2.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
+  fs5.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
   log.info(`build update json to '${versionPath}'`, { timestamp: true });
 }
 async function buildEntry({
@@ -89,8 +513,8 @@ async function buildEntry({
     },
     vite: mergeConfig({
       plugins: [
-        isESM && import('./esm-4S4XCVEW.js').then((m) => m.esm()),
-        bytecodeOptions && import('./bytecode-7J2ZQDDO.js').then((m) => m.bytecodePlugin("main", bytecodeOptions))
+        isESM && esm(),
+        bytecodeOptions && bytecodePlugin("main", bytecodeOptions)
       ],
       build: {
         sourcemap,
@@ -121,21 +545,21 @@ async function defaultZipFile(buffer) {
   });
 }
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = path3.dirname(privateKeyPath);
-  if (!fs2.existsSync(privateKeyDir)) {
-    fs2.mkdirSync(privateKeyDir, { recursive: true });
+  const privateKeyDir = path5.dirname(privateKeyPath);
+  if (!fs5.existsSync(privateKeyDir)) {
+    fs5.mkdirSync(privateKeyDir, { recursive: true });
   }
-  const certDir = path3.dirname(certPath);
-  if (!fs2.existsSync(certDir)) {
-    fs2.mkdirSync(certDir, { recursive: true });
+  const certDir = path5.dirname(certPath);
+  if (!fs5.existsSync(certDir)) {
+    fs5.mkdirSync(certDir, { recursive: true });
   }
   const { cert, private: privateKey } = generate(subject, {
     keySize: keyLength,
     algorithm: "sha256",
     days
   });
-  fs2.writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  fs2.writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
+  fs5.writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  fs5.writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
 }
 function parseKeys({
   keyLength,
@@ -144,22 +568,22 @@ function parseKeys({
   subject,
   days
 }) {
-  const keysDir = path3.dirname(privateKeyPath);
+  const keysDir = path5.dirname(privateKeyPath);
   let privateKey = process.env.UPDATER_PK;
   let cert = process.env.UPDATER_CERT;
   if (privateKey && cert) {
     log.info("Use `UPDATER_PK` and `UPDATER_CERT` from environment variables", { timestamp: true });
     return { privateKey, cert };
   }
-  if (!fs2.existsSync(keysDir)) {
-    fs2.mkdirSync(keysDir);
+  if (!fs5.existsSync(keysDir)) {
+    fs5.mkdirSync(keysDir);
   }
-  if (!fs2.existsSync(privateKeyPath) || !fs2.existsSync(certPath)) {
+  if (!fs5.existsSync(privateKeyPath) || !fs5.existsSync(certPath)) {
     log.info("No key pair found, generate new key pair", { timestamp: true });
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  privateKey = fs2.readFileSync(privateKeyPath, "utf-8");
-  cert = fs2.readFileSync(certPath, "utf-8");
+  privateKey = fs5.readFileSync(privateKeyPath, "utf-8");
+  cert = fs5.readFileSync(certPath, "utf-8");
   return { privateKey, cert };
 }
 function parseSubjects(subject) {
@@ -167,7 +591,7 @@ function parseSubjects(subject) {
 }
 
 // src/vite/option.ts
-function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
+function parseOptions(isBuild, pkg, sourcemap = false, minify = false, options = {}) {
   const {
     minimumVersion = "0.0.0",
     entry: {
@@ -182,7 +606,8 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
         /^node:.*/,
         /.*\.(node|dll|dylib|so)$/,
         "original-fs",
-        ...builtinModules
+        ...builtinModules,
+        ...isBuild ? [] : Object.keys("dependencies" in pkg ? pkg.dependencies : {})
       ],
       overrideViteOptions = {}
     } = {},
@@ -256,8 +681,11 @@ var debugStartup = async (args) => {
   }
 };
 async function filterErrorMessageStartup(args, filter) {
-  await args.startup(void 0, { stdio: ["inherit", "inherit", "pipe", "ipc"] });
+  await args.startup(void 0, { stdio: ["inherit", "pipe", "pipe", "ipc"] });
   const elec = process.electronApp;
+  elec.stderr.addListener("data", (data) => {
+    console.log(data.toString().trimEnd());
+  });
   elec.stderr.addListener("data", (data) => {
     const message = data.toString();
     if (filter(message)) {
@@ -276,9 +704,9 @@ function fixWinCharEncoding(fn) {
 function getMainFileBaseName(options) {
   let mainFilePath;
   if (typeof options === "string") {
-    mainFilePath = path3.basename(options);
+    mainFilePath = path5.basename(options);
   } else if (Array.isArray(options)) {
-    mainFilePath = path3.basename(options[0]);
+    mainFilePath = path5.basename(options[0]);
   } else {
     const name = options?.index ?? options?.main;
     if (!name) {
@@ -317,7 +745,7 @@ async function electronWithUpdater(options) {
   const isESM = pkg.type === "module";
   let bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
   if (isESM && bytecodeOptions?.enable) {
-    (await import('./constant-ME27JB5D.js')).bytecodeLog.warn(
+    bytecodeLog.warn(
       '`bytecodePlugin` does not support ES module, please remove "type": "module" in package.json',
       { timestamp: true }
     );
@@ -329,21 +757,21 @@ async function electronWithUpdater(options) {
     buildVersionOption,
     postBuild,
     cert
-  } = parseOptions(pkg, sourcemap, minify, updater);
+  } = parseOptions(isBuild, pkg, sourcemap, minify, updater);
   const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath, external } = buildEntryOption;
   try {
-    fs2.rmSync(buildAsarOption.electronDistPath, { recursive: true, force: true });
-    fs2.rmSync(entryOutputDirPath, { recursive: true, force: true });
+    fs5.rmSync(buildAsarOption.electronDistPath, { recursive: true, force: true });
+    fs5.rmSync(entryOutputDirPath, { recursive: true, force: true });
   } catch {
   }
   log.info(`Clear cache files`, { timestamp: true });
   sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = normalizePath(path3.join(entryOutputDirPath, "entry.js"));
-  if (path3.resolve(normalizePath(pkg.main)) !== path3.resolve(_appPath)) {
+  const _appPath = normalizePath(path5.join(entryOutputDirPath, "entry.js"));
+  if (path5.resolve(normalizePath(pkg.main)) !== path5.resolve(_appPath)) {
     throw new Error(`Wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
   const define = {
-    __EIU_ASAR_BASE_NAME__: JSON.stringify(path3.basename(buildAsarOption.asarOutputPath)),
+    __EIU_ASAR_BASE_NAME__: JSON.stringify(path5.basename(buildAsarOption.asarOutputPath)),
     __EIU_ELECTRON_DIST_PATH__: JSON.stringify(normalizePath(buildAsarOption.electronDistPath)),
     __EIU_ENTRY_DIST_PATH__: JSON.stringify(normalizePath(buildEntryOption.entryOutputDirPath)),
     __EIU_IS_DEV__: JSON.stringify(!isBuild),
@@ -362,25 +790,25 @@ async function electronWithUpdater(options) {
     log.info(`Build entry to '${entryOutputDirPath}'`, { timestamp: true });
     await postBuild?.({
       getPathFromEntryOutputDir(...paths) {
-        return path3.join(entryOutputDirPath, ...paths);
+        return path5.join(entryOutputDirPath, ...paths);
       },
       copyToEntryOutputDir({ from, to, skipIfExist = true }) {
-        if (!fs2.existsSync(from)) {
+        if (!fs5.existsSync(from)) {
           log.warn(`${from} not found`, { timestamp: true });
           return;
         }
-        const target = path3.join(entryOutputDirPath, to ?? path3.basename(from));
+        const target = path5.join(entryOutputDirPath, to ?? path5.basename(from));
         copyAndSkipIfExist(from, target, skipIfExist);
       },
       copyModules({ modules, skipIfExist = true }) {
-        const nodeModulesPath = path3.join(entryOutputDirPath, "node_modules");
+        const nodeModulesPath = path5.join(entryOutputDirPath, "node_modules");
         for (const m of modules) {
           const { rootPath } = getPackageInfoSync(m) || {};
           if (!rootPath) {
             log.warn(`Package '${m}' not found`, { timestamp: true });
             continue;
           }
-          copyAndSkipIfExist(rootPath, path3.join(nodeModulesPath, m), skipIfExist);
+          copyAndSkipIfExist(rootPath, path5.join(nodeModulesPath, m), skipIfExist);
         }
       }
     });
@@ -390,7 +818,6 @@ async function electronWithUpdater(options) {
     external,
     treeshake: true
   };
-  const esmShimPlugin = isESM ? import('./esm-4S4XCVEW.js').then((m) => m.esm()) : void 0;
   const electronPluginOptions = {
     main: {
       entry: _main.files,
@@ -408,9 +835,9 @@ async function electronWithUpdater(options) {
       vite: mergeConfig(
         {
           plugins: [
-            !isBuild && useNotBundle ? notBundle() : void 0,
-            bytecodeOptions && import('./bytecode-7J2ZQDDO.js').then((m) => m.bytecodePlugin("main", bytecodeOptions)),
-            esmShimPlugin
+            !isBuild && useNotBundle && notBundle(),
+            bytecodeOptions && bytecodePlugin("main", bytecodeOptions),
+            isESM && esm()
           ],
           build: {
             sourcemap,
@@ -429,8 +856,8 @@ async function electronWithUpdater(options) {
       vite: mergeConfig(
         {
           plugins: [
-            bytecodeOptions && import('./bytecode-7J2ZQDDO.js').then((m) => m.bytecodePlugin("preload", bytecodeOptions)),
-            esmShimPlugin,
+            bytecodeOptions && bytecodePlugin("preload", bytecodeOptions),
+            isESM && esm(),
             {
               name: `${id}-build`,
               enforce: "post",
@@ -461,25 +888,26 @@ async function electronWithUpdater(options) {
     }
   };
   if (logParsedOptions) {
+    const shouldShowKey = typeof logParsedOptions === "object" && logParsedOptions.showKeys === true;
     log.info(
       JSON.stringify(
         {
           ...electronPluginOptions,
           updater: { buildAsarOption, buildEntryOption, buildVersionOption }
         },
-        (key, value) => ["privateKey", "cert", "define"].includes(key) && !(typeof logParsedOptions === "object" && logParsedOptions.showKeys === true) ? "***" : value,
+        (key, value) => (key === "privateKey" || key === "cert") && shouldShowKey ? `<${key.toUpperCase()}>` : value,
         2
       ),
       { timestamp: true }
     );
   }
-  let extraHmrPlugin;
+  const result = [ElectronSimple(electronPluginOptions)];
   if (nativeModuleEntryMap) {
     const files = [
       ...Object.values(nativeModuleEntryMap),
       appEntryPath
-    ].map((file) => path3.resolve(normalizePath(file)));
-    extraHmrPlugin = {
+    ].map((file) => path5.resolve(normalizePath(file)));
+    result.push({
       name: `${id}-dev`,
       apply() {
         return !isBuild;
@@ -510,9 +938,9 @@ async function electronWithUpdater(options) {
           }
         );
       }
-    };
+    });
   }
-  return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
+  return result;
 }
 
-export { debugStartup, vite_default as default, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };
+export { convertLiteral, debugStartup, vite_default as default, electronWithUpdater, filterErrorMessageStartup, fixWinCharEncoding };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "electron-incremental-update",
   "type": "module",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "description": "Electron incremental update tools with Vite plugin, support bytecode protection",
   "author": "subframe7536",
   "license": "MIT",

package/dist/bytecode-7J2ZQDDO.js

@@ -1,167 +0,0 @@
-import { readableSize } from './chunk-TPTWE33H.js';
-import { convertArrowFunctionAndTemplate, bytecodeModuleLoader, bytecodeModuleLoaderCode, convertLiteral, compileToBytecode, useStrict, toRelativePath } from './chunk-LR7LR5WG.js';
-import { bytecodeLog, bytecodeId } from './chunk-5NKEXGI3.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import MagicString from 'magic-string';
-import { createFilter, normalizePath } from 'vite';
-
-function getBytecodeLoaderBlock(chunkFileName) {
-  return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`;
-}
-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;
-      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(
-                  new RegExp(`(${useStrict})|("use strict";)`),
-                  `${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-5NKEXGI3.js

@@ -1,10 +0,0 @@
-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-LR7LR5WG.js

@@ -1,192 +0,0 @@
-import { bytecodeLog } from './chunk-5NKEXGI3.js';
-import cp from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import * as babel from '@babel/core';
-import { getPackageInfoSync } from 'local-pkg';
-import MagicString from 'magic-string';
-
-// 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';
-
-// 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;
-}
-var is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
-function isUpdateJSON(json) {
-  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;
-}
-
-// src/vite/bytecode/utils.ts
-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}`;
-}
-var logErr = (...args) => bytecodeLog.error(args.join(" "), { timestamp: true });
-function compileToBytecode(code, electronPath = getElectronPath()) {
-  let data = Buffer.from([]);
-  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, bytecodeModuleLoaderCode, compileToBytecode, convertArrowFunctionAndTemplate, convertLiteral, defaultVersionJsonGenerator, electronMajorVersion, isUpdateJSON, toRelativePath, useStrict };

package/dist/chunk-TPTWE33H.js

@@ -1,23 +0,0 @@
-import { log } from './chunk-5NKEXGI3.js';
-import fs from 'node:fs';
-
-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]}`;
-}
-function copyAndSkipIfExist(from, to, skipIfExist) {
-  if (!skipIfExist || !fs.existsSync(to)) {
-    try {
-      fs.cpSync(from, to, { recursive: true });
-    } catch (error) {
-      log.warn(`Copy failed: ${error}`, { timestamp: true });
-    }
-  }
-}
-
-export { copyAndSkipIfExist, readableSize };

package/dist/constant-ME27JB5D.js

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

package/dist/esm-4S4XCVEW.js

@@ -1,64 +0,0 @@
-import { electronMajorVersion } from './chunk-LR7LR5WG.js';
-import { esmId } from './chunk-5NKEXGI3.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
-  };
-}
-
-// 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 };