electron-incremental-update 1.1.0 → 1.2.0

package/dist/vite.js

@@ -1,17 +1,18 @@
 // src/vite.ts
 import { basename as basename2, join as join2, resolve } from "node:path";
-import { cpSync, existsSync as existsSync4, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
-import { createLogger, mergeConfig, normalizePath as normalizePath2 } from "vite";
+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
 import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import Asar from "@electron/asar";
 import { build } from "esbuild";
-import "vite";
+import { mergeConfig } from "vite";
 
 // src/crypto/utils.ts
 import { createHash } from "node:crypto";
@@ -65,14 +66,14 @@ function isUpdateJSON(json) {
 
 // src/utils/zip.ts
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { gunzip, gzip } from "node:zlib";
+import { brotliCompress, brotliDecompress } from "node:zlib";
 async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
   if (!existsSync(filePath)) {
     throw new Error(`path to be zipped not exist: ${filePath}`);
   }
   const buffer = readFileSync(filePath);
   return new Promise((resolve2, reject) => {
-    gzip(buffer, (err, buffer2) => {
+    brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       }
@@ -82,6 +83,194 @@ async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
   });
 }
 
+// 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,
@@ -158,25 +347,66 @@ async function buildEntry({
   entryOutputDirPath,
   nativeModuleEntryMap,
   overrideEsbuildOptions
-}) {
-  await 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
@@ -200,29 +430,10 @@ function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
   writeFileSync3(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
   writeFileSync3(certPath, cert.replace(/\r\n?/g, "\n"));
 }
-var noCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/;
-var existCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/;
-function writeCertToEntry(entryPath, cert) {
-  if (!existsSync3(entryPath)) {
-    throw new Error(`entry not exist: ${entryPath}`);
-  }
-  const file = readFileSync3(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");
-  }
-  writeFileSync3(entryPath, replaced);
-}
 function parseKeys({
   keyLength,
   privateKeyPath,
   certPath,
-  appEntryPath,
   subject,
   days
 }) {
@@ -234,7 +445,6 @@ function parseKeys({
   }
   const privateKey = process.env.UPDATER_PK || readFileSync3(privateKeyPath, "utf-8");
   const cert = process.env.UPDATER_CERT || readFileSync3(certPath, "utf-8");
-  writeCertToEntry(appEntryPath, cert);
   return { privateKey, cert };
 }
 function parseSubjects(subject) {
@@ -296,7 +506,6 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
     keyLength,
     privateKeyPath,
     certPath,
-    appEntryPath,
     subject,
     days
   });
@@ -310,37 +519,176 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
     generateSignature,
     generateVersionJson
   };
-  return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild };
+  return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert };
 }
 
-// src/constant.ts
-var id = "electron-incremental-updater";
-var bytecodeId = `${id}-bytecode`;
-var loaderId = `${id}-loader`;
+// 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();
 }
-function resolvePackageJson(root = process.cwd()) {
-  const packageJsonPath = join2(root, "package.json");
-  const packageJsonStr = readFileSync4(packageJsonPath, "utf8");
-  try {
-    return JSON.parse(packageJsonStr);
-  } catch {
-    return null;
-  }
-}
-var log = createLogger("info", { prefix: `[${id}]` });
-function electronWithUpdater(options) {
+async function electronWithUpdater(options) {
   let {
     isBuild,
-    pkg = resolvePackageJson(),
+    pkg = await loadPackageJSON(),
     main: _main,
     preload: _preload,
-    sourcemap,
-    minify,
+    sourcemap = !isBuild,
+    minify = isBuild,
     updater,
+    bytecode,
     useNotBundle = true,
     logParsedOptions
   } = options;
@@ -348,14 +696,22 @@ function electronWithUpdater(options) {
     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 {
     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;
   sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
   const _appPath = normalizePath2(join2(entryOutputDirPath, "entry.js"));
@@ -363,7 +719,7 @@ function electronWithUpdater(options) {
     throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
   const _buildEntry = async () => {
-    await buildEntry(buildEntryOption);
+    await buildEntry(buildEntryOption, cert, isBuild ? bytecodeOptions?.protectedStrings : void 0);
     log.info(`vite build entry to '${entryOutputDirPath}'`, { timestamp: true });
   };
   const _postBuild = postBuild ? async () => await postBuild({
@@ -385,6 +741,13 @@ function electronWithUpdater(options) {
   }) : 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,
@@ -396,16 +759,17 @@ function electronWithUpdater(options) {
         }
         _main.onstart ? _main.onstart(args) : args.startup();
       },
-      vite: mergeConfig(
+      vite: mergeConfig2(
         {
-          plugins: [!isBuild && useNotBundle ? notBundle() : void 0],
+          plugins: [
+            !isBuild && useNotBundle ? notBundle() : void 0,
+            bytecodeOptions && bytecodePlugin(isBuild, "main", bytecodeOptions)
+          ],
           build: {
             sourcemap,
             minify,
             outDir: `${buildAsarOption.electronDistPath}/main`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
+            rollupOptions
           }
         },
         _main.vite ?? {}
@@ -414,9 +778,10 @@ function electronWithUpdater(options) {
     preload: {
       input: _preload.files,
       onstart: _preload.onstart,
-      vite: mergeConfig(
+      vite: mergeConfig2(
         {
           plugins: [
+            bytecodeOptions && bytecodePlugin(isBuild, "preload", bytecodeOptions),
             {
               name: `${id}-build`,
               enforce: "post",
@@ -437,9 +802,7 @@ function electronWithUpdater(options) {
             sourcemap: sourcemap ? "inline" : void 0,
             minify,
             outDir: `${buildAsarOption.electronDistPath}/preload`,
-            rollupOptions: {
-              external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
-            }
+            rollupOptions
           }
         },
         _preload.vite ?? {}
@@ -452,7 +815,7 @@ function electronWithUpdater(options) {
         ...electronPluginOptions,
         updater: { buildAsarOption, buildEntryOption, buildVersionOption }
       },
-      (key, value) => key === "privateKey" || key === "cert" ? "***" : value,
+      (key, value) => (key === "privateKey" || key === "cert") && !(typeof logParsedOptions === "object" && logParsedOptions.showKeys === true) ? "***" : value,
       2
     ),
     { timestamp: true }
@@ -481,6 +844,5 @@ function electronWithUpdater(options) {
 }
 export {
   debugStartup,
-  electronWithUpdater,
-  log
+  electronWithUpdater
 };