electron-incremental-update 1.0.3 → 1.2.0

package/dist/vite.js

@@ -1,74 +1,42 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/vite.ts
-var vite_exports = {};
-__export(vite_exports, {
-  debugStartup: () => debugStartup,
-  electronWithUpdater: () => electronWithUpdater,
-  log: () => log
-});
-module.exports = __toCommonJS(vite_exports);
-var import_node_path3 = require("path");
-var import_node_fs4 = require("fs");
-var import_vite3 = require("vite");
-var import_simple = __toESM(require("vite-plugin-electron/simple"));
-var import_vite_plugin_electron = require("vite-plugin-electron");
-var import_plugin = require("vite-plugin-electron/plugin");
+import { basename as basename2, join as join2, resolve } from "node:path";
+import { cpSync, existsSync as existsSync4, rmSync as rmSync2 } from "node:fs";
+import { mergeConfig as mergeConfig2, normalizePath as normalizePath2 } from "vite";
+import ElectronSimple from "vite-plugin-electron/simple";
+import { startup } from "vite-plugin-electron";
+import { notBundle } from "vite-plugin-electron/plugin";
+import { loadPackageJSON } from "local-pkg";
 
 // src/build-plugins/build.ts
-var import_promises = require("fs/promises");
-var import_node_fs2 = require("fs");
-var import_node_path = require("path");
-var import_asar = __toESM(require("@electron/asar"));
-var import_esbuild = require("esbuild");
+import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, join } from "node:path";
+import Asar from "@electron/asar";
+import { build } from "esbuild";
+import { mergeConfig } from "vite";
+
+// src/crypto/utils.ts
+import { createHash } from "node:crypto";
+function hashString(data, length) {
+  const hash = createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
 
-// src/crypto.ts
-var import_node_crypto = require("crypto");
-function encrypt(plainText, key2, iv) {
-  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-cbc", key2, iv);
+// src/crypto/enc.ts
+import { createCipheriv, createPrivateKey, createSign } from "node:crypto";
+function encrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
   let encrypted = cipher.update(plainText, "utf8", "base64url");
   encrypted += cipher.final("base64url");
   return encrypted;
 }
-function key(data, length) {
-  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
-  return Buffer.from(hash).subarray(0, length);
-}
 var signature = (buffer, privateKey, cert, version) => {
-  const sig = (0, import_node_crypto.createSign)("RSA-SHA256").update(buffer).sign((0, import_node_crypto.createPrivateKey)(privateKey), "base64");
-  return encrypt(`${sig}%${version}`, key(cert, 32), key(buffer, 16));
+  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
 };
 
-// src/utils/noDep.ts
+// src/utils/pure.ts
 function parseVersion(version) {
-  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i;
   const match = semver.exec(version);
   if (!match) {
     throw new TypeError(`invalid version: ${version}`);
@@ -97,24 +65,212 @@ function isUpdateJSON(json) {
 }
 
 // src/utils/zip.ts
-var import_node_fs = require("fs");
-var import_node_zlib = require("zlib");
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { brotliCompress, brotliDecompress } from "node:zlib";
 async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs.existsSync)(filePath)) {
+  if (!existsSync(filePath)) {
     throw new Error(`path to be zipped not exist: ${filePath}`);
   }
-  const buffer = (0, import_node_fs.readFileSync)(filePath);
+  const buffer = readFileSync(filePath);
   return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.gzip)(buffer, (err, buffer2) => {
+    brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       }
-      (0, import_node_fs.writeFileSync)(targetFilePath, buffer2);
+      writeFileSync(targetFilePath, buffer2);
       resolve2(null);
     });
   });
 }
 
+// src/build-plugins/log.ts
+import { createLogger } from "vite";
+
+// src/build-plugins/constant.ts
+var id = "electron-incremental-updater";
+var bytecodeId = `${id}-bytecode`;
+var loaderId = `${id}-loader`;
+
+// src/build-plugins/log.ts
+var log = createLogger("info", { prefix: `[${id}]` });
+var bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
+
+// src/build-plugins/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";`,
+  `const fs = require("fs");`,
+  `const path = require("path");`,
+  `const vm = require("vm");`,
+  `const v8 = require("v8");`,
+  `const Module = require("module");`,
+  `v8.setFlagsFromString("--no-lazy");`,
+  `v8.setFlagsFromString("--no-flush-bytecode");`,
+  `const FLAG_HASH_OFFSET = 12;`,
+  `const SOURCE_HASH_OFFSET = 8;`,
+  `let dummyBytecode;`,
+  `function setFlagHashHeader(bytecodeBuffer) {`,
+  `  if (!dummyBytecode) {`,
+  `    const script = new vm.Script("", {`,
+  `      produceCachedData: true`,
+  `    });`,
+  `    dummyBytecode = script.createCachedData();`,
+  `  }`,
+  `  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);`,
+  `};`,
+  `function getSourceHashHeader(bytecodeBuffer) {`,
+  `  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);`,
+  `};`,
+  `function buffer2Number(buffer) {`,
+  `  let ret = 0;`,
+  `  ret |= buffer[3] << 24;`,
+  `  ret |= buffer[2] << 16;`,
+  `  ret |= buffer[1] << 8;`,
+  `  ret |= buffer[0];`,
+  `  return ret;`,
+  `};`,
+  `Module._extensions[".jsc"] = Module._extensions[".cjsc"] = function (module, filename) {`,
+  `  const bytecodeBuffer = fs.readFileSync(filename);`,
+  `  if (!Buffer.isBuffer(bytecodeBuffer)) {`,
+  `    throw new Error("BytecodeBuffer must be a buffer object.");`,
+  `  }`,
+  `  setFlagHashHeader(bytecodeBuffer);`,
+  `  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));`,
+  `  let dummyCode = "";`,
+  `  if (length > 1) {`,
+  `    dummyCode = "\\"" + "\\u200b".repeat(length - 2) + "\\"";`,
+  `  }`,
+  `  const script = new vm.Script(dummyCode, {`,
+  `    filename: filename,`,
+  `    lineOffset: 0,`,
+  `    displayErrors: true,`,
+  `    cachedData: bytecodeBuffer`,
+  `  });`,
+  `  if (script.cachedDataRejected) {`,
+  `    throw new Error("Invalid or incompatible cached data (cachedDataRejected)");`,
+  `  }`,
+  `  const require = function (id) {`,
+  `    return module.require(id);`,
+  `  };`,
+  `  require.resolve = function (request, options) {`,
+  `    return Module._resolveFilename(request, module, false, options);`,
+  `  };`,
+  `  if (process.mainModule) {`,
+  `    require.main = process.mainModule;`,
+  `  }`,
+  `  require.extensions = Module._extensions;`,
+  `  require.cache = Module._cache;`,
+  `  const compiledWrapper = script.runInThisContext({`,
+  `    filename: filename,`,
+  `    lineOffset: 0,`,
+  `    columnOffset: 0,`,
+  `    displayErrors: true`,
+  `  });`,
+  `  const dirname = path.dirname(filename);`,
+  `  const args = [module.exports, require, module, filename, dirname, process, global];`,
+  `  return compiledWrapper.apply(module.exports, args);`,
+  `};`
+].join("\n");
+
+// src/build-plugins/bytecode/utils.ts
+import path from "node:path";
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+import * as babel from "@babel/core";
+import MagicString from "magic-string";
+import { getPackageInfoSync } from "local-pkg";
+var electronModulePath = getPackageInfoSync("electron")?.rootPath;
+var useStrict = "'use strict';";
+var bytecodeModuleLoader = "__loader__.js";
+function getElectronPath() {
+  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(electronModulePath, "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) {
+  let data = Buffer.from([]);
+  const logErr = (...args) => log.error(args.join(" "), { timestamp: true });
+  const electronPath = getElectronPath();
+  const bytecodePath = getBytecodeCompilerPath();
+  return new Promise((resolve2, reject) => {
+    const proc = 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", () => resolve2(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", () => resolve2(data));
+  });
+}
+function convertArrowToFunction(code) {
+  const result = babel.transform(code, {
+    plugins: ["@babel/plugin-transform-arrow-functions"]
+  });
+  return {
+    code: result?.code || code,
+    map: result?.map
+  };
+}
+function escapeRegExpString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/[|{}()[\]^$+*?.]/g, "\\$&");
+}
+function convertString(code, strings, sourcemap) {
+  let s = null;
+  for (const str of strings.filter(Boolean)) {
+    const regex = new RegExp(`["']${escapeRegExpString(str)}["']`, "g");
+    s ||= new MagicString(code).replace(regex, (match) => obfuscateString(match.slice(1, -1)));
+  }
+  return s ? {
+    code: s.toString(),
+    map: sourcemap ? s.generateMap({ hires: "boundary" }) : null
+  } : { code };
+}
+function obfuscateString(input) {
+  const offset = Math.floor(Math.random() * 2 << 4) + 1;
+  const hexArray = Array.from(input).map((c) => "0x" + (c.charCodeAt(0) + offset).toString(16));
+  const decodeFn = `function(a,b){return String.fromCharCode.apply(null,a.map(x=>+x-b))}`;
+  return `(${decodeFn})([${hexArray.join(",")}],${offset})`;
+}
+
 // src/build-plugins/build.ts
 async function buildAsar({
   version,
@@ -123,9 +279,9 @@ async function buildAsar({
   electronDistPath,
   rendererDistPath
 }) {
-  await (0, import_promises.rename)(rendererDistPath, (0, import_node_path.join)(electronDistPath, "renderer"));
-  await (0, import_promises.writeFile)((0, import_node_path.join)(electronDistPath, "version"), version);
-  await import_asar.default.createPackage(electronDistPath, asarOutputPath);
+  renameSync(rendererDistPath, join(electronDistPath, "renderer"));
+  writeFileSync2(join(electronDistPath, "version"), version);
+  await Asar.createPackage(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
 async function buildVersion({
@@ -150,9 +306,9 @@ async function buildVersion({
     size: 0,
     version
   };
-  if ((0, import_node_fs2.existsSync)(versionPath)) {
+  if (existsSync2(versionPath)) {
     try {
-      const oldVersionJson = JSON.parse(await (0, import_promises.readFile)(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(readFileSync2(versionPath, "utf-8"));
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
@@ -161,7 +317,7 @@ async function buildVersion({
     } catch (error) {
     }
   }
-  const buffer = await (0, import_promises.readFile)(gzipPath);
+  const buffer = readFileSync2(gzipPath);
   const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
   if (generateVersionJson) {
     _json = await generateVersionJson(_json, buffer, sig, version, minimumVersion);
@@ -182,7 +338,7 @@ async function buildVersion({
       _json.size = buffer.length;
     }
   }
-  await (0, import_promises.writeFile)(versionPath, JSON.stringify(_json, null, 2));
+  writeFileSync2(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
   sourcemap,
@@ -191,83 +347,104 @@ async function buildEntry({
   entryOutputDirPath,
   nativeModuleEntryMap,
   overrideEsbuildOptions
-}) {
-  await (0, import_esbuild.build)({
-    entryPoints: {
-      entry: appEntryPath,
-      ...nativeModuleEntryMap
-    },
-    bundle: true,
-    platform: "node",
-    outdir: entryOutputDirPath,
-    minify,
-    sourcemap,
-    entryNames: "[dir]/[name]",
-    assetNames: "[dir]/[name]",
-    external: ["electron", "original-fs"],
-    loader: {
-      ".node": "empty"
+}, cert, protectedStrings) {
+  const option = mergeConfig(
+    {
+      entryPoints: {
+        entry: appEntryPath,
+        ...nativeModuleEntryMap
+      },
+      bundle: true,
+      metafile: true,
+      platform: "node",
+      outdir: entryOutputDirPath,
+      minify,
+      sourcemap,
+      entryNames: "[dir]/[name]",
+      assetNames: "[dir]/[name]",
+      external: ["electron", "original-fs"],
+      loader: {
+        ".node": "empty"
+      },
+      define: {
+        __SIGNATURE_CERT__: JSON.stringify(cert)
+      }
     },
-    ...overrideEsbuildOptions
-  });
+    overrideEsbuildOptions ?? {}
+  );
+  const { metafile } = await build(option);
+  if (protectedStrings === void 0) {
+    return;
+  }
+  const filePaths = Object.keys(metafile?.outputs ?? []);
+  for (const filePath of filePaths) {
+    let code = readFileSync2(filePath, "utf-8");
+    const fileName = basename(filePath);
+    const isEntry = fileName.endsWith("entry.js");
+    if (isEntry) {
+      code = code.replace(
+        /(`-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\n`)/,
+        (_, cert2) => `"${cert2.slice(1, -1).replace(/\n/g, "\\n")}"`
+      );
+    }
+    const transformedCode = convertString(
+      convertArrowToFunction(code).code,
+      [...protectedStrings, ...isEntry ? getCert(code) : []]
+    ).code;
+    const buffer = await compileToBytecode(transformedCode);
+    writeFileSync2(`${filePath}c`, buffer);
+    writeFileSync2(
+      filePath,
+      `${isEntry ? bytecodeModuleLoaderCode : useStrict}${isEntry ? "" : "module.exports = "}require("./${fileName}c")`
+    );
+    bytecodeLog.info(
+      `${filePath} => ${(buffer.byteLength / 1e3).toFixed(2)} kB`,
+      { timestamp: true }
+    );
+  }
+  bytecodeLog.info(`${filePaths.length} bundles compiled into bytecode`, { timestamp: true });
+}
+function getCert(code) {
+  const cert = code.match(/-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n/)?.[0];
+  return cert ? [cert] : [];
 }
 
 // src/build-plugins/key.ts
-var import_node_fs3 = require("fs");
-var import_node_path2 = require("path");
-var import_selfsigned = require("selfsigned");
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname } from "node:path";
+import { generate } from "selfsigned";
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = (0, import_node_path2.dirname)(privateKeyPath);
-  if (!(0, import_node_fs3.existsSync)(privateKeyDir)) {
-    (0, import_node_fs3.mkdirSync)(privateKeyDir, { recursive: true });
+  const privateKeyDir = dirname(privateKeyPath);
+  if (!existsSync3(privateKeyDir)) {
+    mkdirSync(privateKeyDir, { recursive: true });
   }
-  const certDir = (0, import_node_path2.dirname)(certPath);
-  if (!(0, import_node_fs3.existsSync)(certDir)) {
-    (0, import_node_fs3.mkdirSync)(certDir, { recursive: true });
+  const certDir = dirname(certPath);
+  if (!existsSync3(certDir)) {
+    mkdirSync(certDir, { recursive: true });
   }
-  const { cert, private: privateKey } = (0, import_selfsigned.generate)(subject, {
+  const { cert, private: privateKey } = generate(subject, {
     keySize: keyLength,
     algorithm: "sha256",
     days
   });
-  (0, import_node_fs3.writeFileSync)(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  (0, import_node_fs3.writeFileSync)(certPath, cert.replace(/\r\n?/g, "\n"));
-}
-var noCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/m;
-var existCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/m;
-function writeCertToEntry(entryPath, cert) {
-  if (!(0, import_node_fs3.existsSync)(entryPath)) {
-    throw new Error(`entry not exist: ${entryPath}`);
-  }
-  const file = (0, import_node_fs3.readFileSync)(entryPath, "utf-8");
-  const replacement = cert.split("\n").filter(Boolean).map((s) => `'${s}\\n'`).join("\n  + ");
-  let replaced = file;
-  if (noCertRegex.test(file)) {
-    replaced = file.replace(noCertRegex, replacement);
-  } else if (existCertRegex.test(file)) {
-    replaced = file.replace(existCertRegex, replacement);
-  } else {
-    throw new Error("no `SIGNATURE_CERT` found in entry");
-  }
-  (0, import_node_fs3.writeFileSync)(entryPath, replaced);
+  writeFileSync3(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  writeFileSync3(certPath, cert.replace(/\r\n?/g, "\n"));
 }
 function parseKeys({
   keyLength,
   privateKeyPath,
   certPath,
-  appEntryPath,
   subject,
   days
 }) {
-  const keysDir = (0, import_node_path2.dirname)(privateKeyPath);
-  !(0, import_node_fs3.existsSync)(keysDir) && (0, import_node_fs3.mkdirSync)(keysDir);
-  if (!(0, import_node_fs3.existsSync)(privateKeyPath) || !(0, import_node_fs3.existsSync)(certPath)) {
+  const keysDir = dirname(privateKeyPath);
+  !existsSync3(keysDir) && mkdirSync(keysDir);
+  if (!existsSync3(privateKeyPath) || !existsSync3(certPath)) {
     log.warn("no key pair found, generate new key pair");
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  const privateKey = process.env.UPDATER_PK || (0, import_node_fs3.readFileSync)(privateKeyPath, "utf-8");
-  const cert = process.env.UPDATER_CERT || (0, import_node_fs3.readFileSync)(certPath, "utf-8");
-  writeCertToEntry(appEntryPath, cert);
+  const privateKey = process.env.UPDATER_PK || readFileSync3(privateKeyPath, "utf-8");
+  const cert = process.env.UPDATER_CERT || readFileSync3(certPath, "utf-8");
   return { privateKey, cert };
 }
 function parseSubjects(subject) {
@@ -275,12 +452,12 @@ function parseSubjects(subject) {
 }
 
 // src/build-plugins/option.ts
-function parseOptions(isBuild, pkg, options = {}) {
+function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
   const {
     minimumVersion = "0.0.0",
     entry: {
-      minify = isBuild,
-      sourcemap = isBuild,
+      minify: entryMinify,
+      sourcemap: entrySourcemap,
       entryOutputDirPath = "dist-entry",
       appEntryPath = "electron/entry.ts",
       nativeModuleEntryMap = {},
@@ -318,8 +495,8 @@ function parseOptions(isBuild, pkg, options = {}) {
     rendererDistPath
   };
   const buildEntryOption = {
-    minify,
-    sourcemap,
+    minify: entryMinify ?? minify,
+    sourcemap: entrySourcemap ?? sourcemap,
     entryOutputDirPath,
     appEntryPath,
     nativeModuleEntryMap,
@@ -329,7 +506,6 @@ function parseOptions(isBuild, pkg, options = {}) {
     keyLength,
     privateKeyPath,
     certPath,
-    appEntryPath,
     subject,
     days
   });
@@ -343,62 +519,235 @@ function parseOptions(isBuild, pkg, options = {}) {
     generateSignature,
     generateVersionJson
   };
-  return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild };
+  return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert };
+}
+
+// src/build-plugins/bytecode/index.ts
+import path2 from "node:path";
+import fs2 from "node:fs";
+import { createFilter, normalizePath } from "vite";
+import MagicString2 from "magic-string";
+function bytecodePlugin(isBuild, env, options = {}) {
+  if (!isBuild) {
+    return null;
+  }
+  const {
+    protectedStrings = [],
+    enablePreload = false
+  } = options;
+  if (!enablePreload && 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 (protectedStrings.length === 0 || !filter(id2)) {
+        return;
+      }
+      return convertString(code, protectedStrings, !!config.build.sourcemap);
+    },
+    generateBundle(options2) {
+      if (options2.format !== "es" && bytecodeRequired) {
+        this.emitFile({
+          type: "asset",
+          source: bytecodeModuleLoaderCode + "\n",
+          name: "Bytecode Loader File",
+          fileName: bytecodeModuleLoader
+        });
+      }
+    },
+    renderChunk(code, chunk, options2) {
+      if (options2.format === "es") {
+        bytecodeLog.warn(
+          'bytecodePlugin does not support ES module, please remove "type": "module" in package.json or set the "build.rollupOptions.output.format" option to "cjs".',
+          { timestamp: true }
+        );
+        return null;
+      }
+      if (chunk.type === "chunk") {
+        bytecodeRequired = true;
+        return convertArrowToFunction(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) => path2.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;
+            if (bytecodeRE && _code.match(bytecodeRE)) {
+              let match;
+              const s = new MagicString2(_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();
+            }
+            const chunkFilePath = path2.resolve(outDir, name);
+            if (bytecodeChunks.includes(name)) {
+              const bytecodeBuffer = await compileToBytecode(_code);
+              fs2.writeFileSync(path2.resolve(outDir, name + "c"), bytecodeBuffer);
+              if (chunk.isEntry) {
+                const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+                const bytecodeModuleBlock = `require("./${path2.basename(name) + "c"}");`;
+                const code = `${useStrict}
+${bytecodeLoaderBlock}
+module.exports=${bytecodeModuleBlock}
+`;
+                fs2.writeFileSync(chunkFilePath, code);
+              } else {
+                fs2.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;
+              }
+              fs2.writeFileSync(chunkFilePath, _code);
+            }
+          }
+        })
+      );
+    },
+    closeBundle() {
+      const outDir = `${normalizePath(path2.relative(config.root, path2.resolve(config.root, config.build.outDir)))}/`;
+      bytecodeFiles.forEach((file) => {
+        const kbs = file.size / 1e3;
+        bytecodeLog.info(
+          `${outDir}${file.name} => ${kbs.toFixed(2)} kB`,
+          { timestamp: true }
+        );
+      });
+      bytecodeLog.info(`${bytecodeFiles.length} bundles compiled into bytecode.`, { timestamp: true });
+      bytecodeFiles = [];
+    }
+  };
 }
 
 // src/vite.ts
 function debugStartup(args) {
   process.env.VSCODE_DEBUG ? console.log("[startup] Electron App") : args.startup();
 }
-var id = "electron-incremental-updater";
-var log = (0, import_vite3.createLogger)("info", { prefix: `[${id}]` });
-function electronWithUpdater(options) {
-  const {
+async function electronWithUpdater(options) {
+  let {
     isBuild,
-    pkg,
+    pkg = await loadPackageJSON(),
     main: _main,
     preload: _preload,
+    sourcemap = !isBuild,
+    minify = isBuild,
     updater,
+    bytecode,
     useNotBundle = true,
     logParsedOptions
   } = options;
-  const _options = parseOptions(isBuild, pkg, updater);
+  if (!pkg) {
+    log.error(`package.json not found`, { timestamp: true });
+    return null;
+  }
+  if (!pkg.version || !pkg.name || !pkg.main) {
+    log.error(`package.json not valid`, { timestamp: true });
+    return null;
+  }
+  const _options = parseOptions(pkg, sourcemap, minify, updater);
+  const bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { protectedStrings: [] } : void 0;
+  if (bytecodeOptions) {
+    minify = false;
+  }
   try {
-    (0, import_node_fs4.rmSync)(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
-    (0, import_node_fs4.rmSync)(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
+    rmSync2(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
+    rmSync2(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
   } catch (ignore) {
   }
   log.info(`remove old files`, { timestamp: true });
-  const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild } = _options;
+  const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = _options;
   const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
-  const sourcemap = isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = (0, import_node_path3.join)(entryOutputDirPath, "entry.js");
-  if ((0, import_node_path3.resolve)((0, import_vite3.normalizePath)(pkg.main)) !== (0, import_node_path3.resolve)((0, import_vite3.normalizePath)(_appPath))) {
-    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${(0, import_vite3.normalizePath)(_appPath)}"`);
+  sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
+  const _appPath = normalizePath2(join2(entryOutputDirPath, "entry.js"));
+  if (resolve(normalizePath2(pkg.main)) !== resolve(_appPath)) {
+    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
-  let isInit = false;
   const _buildEntry = async () => {
-    await buildEntry(buildEntryOption);
-    log.info(`build entry to '${entryOutputDirPath}'`, { timestamp: true });
+    await buildEntry(buildEntryOption, cert, isBuild ? bytecodeOptions?.protectedStrings : void 0);
+    log.info(`vite build entry to '${entryOutputDirPath}'`, { timestamp: true });
   };
-  const _postBuild = postBuild ? async () => postBuild({
+  const _postBuild = postBuild ? async () => await postBuild({
     getPathFromEntryOutputDir(...paths) {
-      return (0, import_node_path3.join)(entryOutputDirPath, ...paths);
+      return join2(entryOutputDirPath, ...paths);
     },
-    existsAndCopyToEntryOutputDir({ from, to, skipIfExist = true }) {
-      if ((0, import_node_fs4.existsSync)(from)) {
-        const target = (0, import_node_path3.join)(entryOutputDirPath, to ?? (0, import_node_path3.basename)(from));
-        if (!skipIfExist || !(0, import_node_fs4.existsSync)(target)) {
+    copyToEntryOutputDir({ from, to, skipIfExist = true }) {
+      if (existsSync4(from)) {
+        const target = join2(entryOutputDirPath, to ?? basename2(from));
+        if (!skipIfExist || !existsSync4(target)) {
           try {
-            (0, import_node_fs4.cpSync)(from, target);
-          } catch (ignore) {
-            log.warn(`copy failed: ${ignore}`);
+            cpSync(from, target);
+          } catch (error) {
+            log.warn(`copy failed: ${error}`);
           }
         }
       }
     }
   }) : async () => {
   };
+  let isInit = false;
+  const rollupOptions = {
+    // external: [
+    //   /^node:/,
+    //   ...Object.keys('dependencies' in pkg ? pkg.dependencies as object : {}),
+    // ],
+    external: (src) => src.startsWith("node:") || Object.keys("dependencies" in pkg ? pkg.dependencies : {}).includes(src)
+  };
   const electronPluginOptions = {
     main: {
       entry: _main.files,
@@ -410,16 +759,17 @@ function electronWithUpdater(options) {
         }
         _main.onstart ? _main.onstart(args) : args.startup();
       },
-      vite: (0, import_vite3.mergeConfig)(
+      vite: mergeConfig2(
         {
-          plugins: !isBuild && useNotBundle ? [(0, import_plugin.notBundle)()] : void 0,
+          plugins: [
+            !isBuild && useNotBundle ? notBundle() : void 0,
+            bytecodeOptions && bytecodePlugin(isBuild, "main", bytecodeOptions)
+          ],
           build: {
             sourcemap,
-            minify: isBuild,
+            minify,
             outDir: `${buildAsarOption.electronDistPath}/main`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
+            rollupOptions
           }
         },
         _main.vite ?? {}
@@ -428,9 +778,10 @@ function electronWithUpdater(options) {
     preload: {
       input: _preload.files,
       onstart: _preload.onstart,
-      vite: (0, import_vite3.mergeConfig)(
+      vite: mergeConfig2(
         {
           plugins: [
+            bytecodeOptions && bytecodePlugin(isBuild, "preload", bytecodeOptions),
             {
               name: `${id}-build`,
               enforce: "post",
@@ -439,6 +790,7 @@ function electronWithUpdater(options) {
               },
               async closeBundle() {
                 await _buildEntry();
+                await _postBuild();
                 await buildAsar(buildAsarOption);
                 log.info(`build asar to '${buildAsarOption.asarOutputPath}'`, { timestamp: true });
                 await buildVersion(buildVersionOption);
@@ -448,11 +800,9 @@ function electronWithUpdater(options) {
           ],
           build: {
             sourcemap: sourcemap ? "inline" : void 0,
-            minify: isBuild,
+            minify,
             outDir: `${buildAsarOption.electronDistPath}/preload`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
+            rollupOptions
           }
         },
         _preload.vite ?? {}
@@ -465,14 +815,14 @@ function electronWithUpdater(options) {
         ...electronPluginOptions,
         updater: { buildAsarOption, buildEntryOption, buildVersionOption }
       },
-      (key2, value) => key2 === "privateKey" || key2 === "cert" ? "***" : value,
+      (key, value) => (key === "privateKey" || key === "cert") && !(typeof logParsedOptions === "object" && logParsedOptions.showKeys === true) ? "***" : value,
       2
     ),
     { timestamp: true }
   );
   let extraHmrPlugin;
   if (nativeModuleEntryMap) {
-    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => (0, import_node_path3.resolve)((0, import_vite3.normalizePath)(file)));
+    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath2(file)));
     extraHmrPlugin = {
       name: `${id}-dev`,
       apply() {
@@ -482,19 +832,17 @@ function electronWithUpdater(options) {
         server.watcher.add(files).on(
           "change",
           (p) => files.includes(p) && _buildEntry().then(async () => {
-            await import_vite_plugin_electron.startup.exit();
+            await startup.exit();
             await _postBuild();
-            await (0, import_vite_plugin_electron.startup)();
+            await startup();
           })
         );
       }
     };
   }
-  return [(0, import_simple.default)(electronPluginOptions), extraHmrPlugin];
+  return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   debugStartup,
-  electronWithUpdater,
-  log
-});
+  electronWithUpdater
+};