electron-incremental-update 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/{chunk-DFNDKSE6.js → chunk-4MH6ZXCY.js}

@@ -1,23 +1,23 @@
 import { __require } from './chunk-72ZAJ7AF.js';
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import fs from 'node:fs';
+import path from 'node:path';
 import { app } from 'electron';
 
 var isDev = __EIU_IS_DEV__;
 var isWin = process.platform === "win32";
 var isMac = process.platform === "darwin";
 var isLinux = process.platform === "linux";
-function getPathFromAppNameAsar(...path) {
-  return isDev ? "DEV.asar" : join(dirname(app.getAppPath()), `${app.name}.asar`, ...path);
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(app.getAppPath()), `${app.name}.asar`, ...paths);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
   return app.getVersion();
 }
 function requireNative(moduleName) {
-  return __require(join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+  return __require(path.join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
   app.relaunch();
@@ -51,9 +51,9 @@ function singleInstance(window) {
   return result;
 }
 function setPortableAppDataPath(dirName = "data") {
-  const portablePath = join(dirname(app.getPath("exe")), dirName);
-  if (!existsSync(portablePath)) {
-    mkdirSync(portablePath);
+  const portablePath = path.join(path.dirname(app.getPath("exe")), dirName);
+  if (!fs.existsSync(portablePath)) {
+    fs.mkdirSync(portablePath);
   }
   app.setPath("appData", portablePath);
 }
@@ -65,13 +65,13 @@ function loadPage(win, htmlFilePath = "index.html") {
   }
 }
 function getPathFromPreload(...paths) {
-  return isDev ? join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+  return isDev ? path.join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
 }
 function getPathFromPublic(...paths) {
-  return isDev ? join(app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+  return isDev ? path.join(app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
 }
 function getPathFromEntryAsar(...paths) {
-  return join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+  return path.join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
 function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", callback);

package/dist/{chunk-N77WQ5WB.js → chunk-KZSYEXLO.js}

@@ -1,10 +1,10 @@
-import { brotliCompress, brotliDecompress } from 'node:zlib';
-import { createHash, createCipheriv, createSign, createPrivateKey, createDecipheriv, createVerify } from 'node:crypto';
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
 
 // src/utils/zip.ts
 async function defaultZipFile(buffer) {
   return new Promise((resolve, reject) => {
-    brotliCompress(buffer, (err, buffer2) => {
+    zlib.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -15,7 +15,7 @@ async function defaultZipFile(buffer) {
 }
 async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    brotliDecompress(buffer, (err, buffer2) => {
+    zlib.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -25,19 +25,19 @@ async function defaultUnzipFile(buffer) {
   });
 }
 function hashBuffer(data, length) {
-  const hash = createHash("SHA256").update(data).digest("binary");
+  const hash = crypto.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesEncrypt(plainText, key, iv) {
-  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
   return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
 }
 function defaultSignature(buffer, privateKey, cert, version) {
-  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  const sig = crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64");
   return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
 function aesDecrypt(encryptedText, key, iv) {
-  const decipher = createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
   return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
 }
 function defaultVerifySignature(buffer, version, signature, cert) {
@@ -46,7 +46,7 @@ function defaultVerifySignature(buffer, version, signature, cert) {
     if (ver !== version) {
       return false;
     }
-    return createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
   } catch {
     return false;
   }

package/dist/index.cjs

@@ -1,10 +1,15 @@
 'use strict';
 
 var path = require('path');
-var fs = require('fs');
+var fs3 = require('fs');
 var electron = require('electron');
 var events = require('events');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -21,11 +26,11 @@ var isDev = __EIU_IS_DEV__;
 process.platform === "win32";
 process.platform === "darwin";
 process.platform === "linux";
-function getPathFromAppNameAsar(...path$1) {
-  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...path$1);
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs3__default.default.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
   return electron.app.getVersion();
@@ -167,14 +172,14 @@ var Updater = class extends events.EventEmitter {
     }
     this.logger?.debug("verify start");
     if (!await this.provider.verifySignaure(buffer, _version, _sig, this.CERT)) {
-      this.err("download failed", "validate", "invalid signature / certificate pair");
+      this.err("download failed", "validate", "invalid update asar file");
       return false;
     }
     this.logger?.debug("verify success");
     try {
       const tmpFilePath = getPathFromAppNameAsar() + ".tmp";
       this.logger?.debug(`install to ${tmpFilePath}`);
-      fs.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
+      fs3__default.default.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
       this.logger?.info(`download success, version: ${_version}`);
       this.info = void 0;
       this.emit("update-downloaded");
@@ -241,12 +246,12 @@ async function initApp(appOptions) {
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if (fs.existsSync(tempAsarPath)) {
+    if (fs3__default.default.existsSync(tempAsarPath)) {
       logger?.info(`installing new asar: ${tempAsarPath}`);
-      await onInstall(() => fs.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+      await onInstall(() => fs3__default.default.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = path.join(
-      isDev ? path.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+    const mainFilePath = path__default.default.join(
+      isDev ? path__default.default.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
       "main",
       __EIU_MAIN_FILE__
     );

package/dist/index.js

@@ -1,7 +1,7 @@
-import { isDev, getEntryVersion, getAppVersion, getPathFromAppNameAsar, restartApp } from './chunk-DFNDKSE6.js';
+import { isDev, getEntryVersion, getAppVersion, getPathFromAppNameAsar, restartApp } from './chunk-4MH6ZXCY.js';
 import { isUpdateJSON, __require } from './chunk-72ZAJ7AF.js';
-import { join } from 'node:path';
-import { writeFileSync, existsSync, renameSync } from 'node:fs';
+import path from 'node:path';
+import fs2 from 'node:fs';
 import { app } from 'electron';
 import { EventEmitter } from 'node:events';
 
@@ -137,14 +137,14 @@ var Updater = class extends EventEmitter {
     }
     this.logger?.debug("verify start");
     if (!await this.provider.verifySignaure(buffer, _version, _sig, this.CERT)) {
-      this.err("download failed", "validate", "invalid signature / certificate pair");
+      this.err("download failed", "validate", "invalid update asar file");
       return false;
     }
     this.logger?.debug("verify success");
     try {
       const tmpFilePath = getPathFromAppNameAsar() + ".tmp";
       this.logger?.debug(`install to ${tmpFilePath}`);
-      writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
+      fs2.writeFileSync(tmpFilePath, await this.provider.unzipFile(buffer));
       this.logger?.info(`download success, version: ${_version}`);
       this.info = void 0;
       this.emit("update-downloaded");
@@ -211,12 +211,12 @@ async function initApp(appOptions) {
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if (existsSync(tempAsarPath)) {
+    if (fs2.existsSync(tempAsarPath)) {
       logger?.info(`installing new asar: ${tempAsarPath}`);
-      await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+      await onInstall(() => fs2.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = join(
-      isDev ? join(app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+    const mainFilePath = path.join(
+      isDev ? path.join(app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
       "main",
       __EIU_MAIN_FILE__
     );

package/dist/provider.cjs

@@ -5,6 +5,11 @@ var electron = require('electron');
 var crypto = require('crypto');
 var zlib = require('zlib');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+
 // src/provider/github.ts
 
 // src/utils/version.ts
@@ -121,11 +126,11 @@ async function defaultDownloadAsar(url, headers, onDownloading) {
   });
 }
 function hashBuffer(data, length) {
-  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesDecrypt(encryptedText, key, iv) {
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
   return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
 }
 function defaultVerifySignature(buffer, version, signature, cert) {
@@ -134,14 +139,14 @@ function defaultVerifySignature(buffer, version, signature, cert) {
     if (ver !== version) {
       return false;
     }
-    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
   } catch {
     return false;
   }
 }
 async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliDecompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {

package/dist/provider.js

@@ -1,4 +1,4 @@
-import { defaultVerifySignature, defaultUnzipFile } from './chunk-N77WQ5WB.js';
+import { defaultVerifySignature, defaultUnzipFile } from './chunk-KZSYEXLO.js';
 import { defaultIsLowerVersion, isUpdateJSON } from './chunk-72ZAJ7AF.js';
 import { URL } from 'node:url';
 import { app, net } from 'electron';

package/dist/utils.cjs

@@ -6,6 +6,13 @@ var electron = require('electron');
 var zlib = require('zlib');
 var crypto = require('crypto');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -16,17 +23,17 @@ var isDev = __EIU_IS_DEV__;
 var isWin = process.platform === "win32";
 var isMac = process.platform === "darwin";
 var isLinux = process.platform === "linux";
-function getPathFromAppNameAsar(...path$1) {
-  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...path$1);
+function getPathFromAppNameAsar(...paths) {
+  return isDev ? "DEV.asar" : path__default.default.join(path__default.default.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...paths);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs__default.default.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
   return electron.app.getVersion();
 }
 function requireNative(moduleName) {
-  return __require(path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+  return __require(path__default.default.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
   electron.app.relaunch();
@@ -60,9 +67,9 @@ function singleInstance(window) {
   return result;
 }
 function setPortableAppDataPath(dirName = "data") {
-  const portablePath = path.join(path.dirname(electron.app.getPath("exe")), dirName);
-  if (!fs.existsSync(portablePath)) {
-    fs.mkdirSync(portablePath);
+  const portablePath = path__default.default.join(path__default.default.dirname(electron.app.getPath("exe")), dirName);
+  if (!fs__default.default.existsSync(portablePath)) {
+    fs__default.default.mkdirSync(portablePath);
   }
   electron.app.setPath("appData", portablePath);
 }
@@ -74,13 +81,13 @@ function loadPage(win, htmlFilePath = "index.html") {
   }
 }
 function getPathFromPreload(...paths) {
-  return isDev ? path.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+  return isDev ? path__default.default.join(electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
 }
 function getPathFromPublic(...paths) {
-  return isDev ? path.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+  return isDev ? path__default.default.join(electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
 }
 function getPathFromEntryAsar(...paths) {
-  return path.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+  return path__default.default.join(electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
 function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", callback);
@@ -88,7 +95,7 @@ function handleUnexpectedErrors(callback) {
 }
 async function defaultZipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliCompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -99,7 +106,7 @@ async function defaultZipFile(buffer) {
 }
 async function defaultUnzipFile(buffer) {
   return new Promise((resolve, reject) => {
-    zlib.brotliDecompress(buffer, (err, buffer2) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
@@ -171,19 +178,19 @@ function defaultVersionJsonGenerator(existingJson, signature, version, minimumVe
   return existingJson;
 }
 function hashBuffer(data, length) {
-  const hash = crypto.createHash("SHA256").update(data).digest("binary");
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesEncrypt(plainText, key, iv) {
-  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+  const cipher = crypto__default.default.createCipheriv("aes-256-cbc", key, iv);
   return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
 }
 function defaultSignature(buffer, privateKey, cert, version) {
-  const sig = crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64");
+  const sig = crypto__default.default.createSign("RSA-SHA256").update(buffer).sign(crypto__default.default.createPrivateKey(privateKey), "base64");
   return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
 function aesDecrypt(encryptedText, key, iv) {
-  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
   return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
 }
 function defaultVerifySignature(buffer, version, signature, cert) {
@@ -192,7 +199,7 @@ function defaultVerifySignature(buffer, version, signature, cert) {
     if (ver !== version) {
       return false;
     }
-    return crypto.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
   } catch {
     return false;
   }

package/dist/utils.d.cts

@@ -17,7 +17,7 @@ declare const isLinux: boolean;
  *
  * if is in dev, **always** return `'DEV.asar'`
  */
-declare function getPathFromAppNameAsar(...path: string[]): string;
+declare function getPathFromAppNameAsar(...paths: string[]): string;
 /**
  * get app version, if is in dev, return `getEntryVersion()`
  */

package/dist/utils.d.ts

@@ -17,7 +17,7 @@ declare const isLinux: boolean;
  *
  * if is in dev, **always** return `'DEV.asar'`
  */
-declare function getPathFromAppNameAsar(...path: string[]): string;
+declare function getPathFromAppNameAsar(...paths: string[]): string;
 /**
  * get app version, if is in dev, return `getEntryVersion()`
  */

package/dist/utils.js

@@ -1,5 +1,5 @@
-export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance } from './chunk-DFNDKSE6.js';
-export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerifySignature, defaultZipFile, hashBuffer } from './chunk-N77WQ5WB.js';
+export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, handleUnexpectedErrors, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance } from './chunk-4MH6ZXCY.js';
+export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerifySignature, defaultZipFile, hashBuffer } from './chunk-KZSYEXLO.js';
 export { defaultIsLowerVersion, defaultVersionJsonGenerator, isUpdateJSON, parseVersion } from './chunk-72ZAJ7AF.js';
 
 // src/utils/updater.ts

package/dist/vite.d.ts

@@ -234,14 +234,17 @@ interface ElectronUpdaterOptions {
 }
 
 interface BytecodeOptions {
+    enable: boolean;
     /**
-     * strings that should be transformed
+     * Remember to set `sandbox: false` when creating window
      */
-    protectedStrings?: string[];
+    preload?: boolean;
     /**
-     * Remember to set `sandbox: false` when creating window
+     * before transformed code compile callback, if return `null` or `undefined`, it will be ignored
+     * @param code transformed code
+     * @param id file path
      */
-    enablePreload?: boolean;
+    beforeCompile?: (code: string, id: string) => Promisable<string | null | undefined>;
 }
 
 type MakeRequired<T, K extends keyof T> = Exclude<T, undefined> & {

package/dist/vite.js

@@ -1,5 +1,5 @@
-import path2, { join, resolve, basename, dirname } from 'node:path';
-import fs, { rmSync, renameSync, writeFileSync, readFileSync, existsSync, cpSync, mkdirSync } from 'node:fs';
+import path5 from 'node:path';
+import fs3 from 'node:fs';
 import { createLogger, normalizePath, mergeConfig, createFilter } from 'vite';
 import ElectronSimple from 'vite-plugin-electron/simple';
 import { startup } from 'vite-plugin-electron';
@@ -9,11 +9,11 @@ import { isCI } from 'ci-info';
 export { isCI } from 'ci-info';
 import Asar from '@electron/asar';
 import { build } from 'esbuild';
-import { spawn } from 'node:child_process';
+import cp from 'node:child_process';
 import * as babel from '@babel/core';
 import MagicString from 'magic-string';
-import { brotliCompress } from 'node:zlib';
-import { createSign, createPrivateKey, createHash, createCipheriv } from 'node:crypto';
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
 import { generate } from 'selfsigned';
 
 // src/vite.ts
@@ -76,13 +76,13 @@ function getElectronPath() {
     if (!electronModulePath) {
       throw new Error("Electron is not installed");
     }
-    const pathFile = path2.join(electronModulePath, "path.txt");
+    const pathFile = path5.join(electronModulePath, "path.txt");
     let executablePath;
-    if (fs.existsSync(pathFile)) {
-      executablePath = fs.readFileSync(pathFile, "utf-8");
+    if (fs3.existsSync(pathFile)) {
+      executablePath = fs3.readFileSync(pathFile, "utf-8");
     }
     if (executablePath) {
-      electronExecPath = path2.join(electronModulePath, "dist", executablePath);
+      electronExecPath = path5.join(electronModulePath, "dist", executablePath);
       process.env.ELECTRON_EXEC_PATH = electronExecPath;
     } else {
       throw new Error("Electron executable file is not existed");
@@ -91,14 +91,14 @@ function getElectronPath() {
   return electronExecPath;
 }
 function getBytecodeCompilerPath() {
-  const scriptPath = path2.join(electronModulePath, "bytenode.cjs");
-  if (!fs.existsSync(scriptPath)) {
-    fs.writeFileSync(scriptPath, bytecodeGeneratorScript);
+  const scriptPath = path5.join(electronModulePath, "bytenode.cjs");
+  if (!fs3.existsSync(scriptPath)) {
+    fs3.writeFileSync(scriptPath, bytecodeGeneratorScript);
   }
   return scriptPath;
 }
 function toRelativePath(filename, importer) {
-  const relPath = path2.posix.relative(path2.dirname(importer), filename);
+  const relPath = path5.posix.relative(path5.dirname(importer), filename);
   return relPath.startsWith(".") ? relPath : `./${relPath}`;
 }
 function compileToBytecode(code) {
@@ -106,8 +106,8 @@ function compileToBytecode(code) {
   const logErr = (...args) => bytecodeLog.error(args.join(" "), { timestamp: true });
   const electronPath = getElectronPath();
   const bytecodePath = getBytecodeCompilerPath();
-  return new Promise((resolve2, reject) => {
-    const proc = spawn(electronPath, [bytecodePath], {
+  return new Promise((resolve, reject) => {
+    const proc = cp.spawn(electronPath, [bytecodePath], {
       env: { ELECTRON_RUN_AS_NODE: "1" },
       stdio: ["pipe", "pipe", "pipe", "ipc"]
     });
@@ -118,7 +118,7 @@ function compileToBytecode(code) {
     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));
+      proc.stdout.on("end", () => resolve(data));
     }
     if (proc.stderr) {
       proc.stderr.on("data", (chunk) => logErr("Error: ", chunk.toString()));
@@ -126,37 +126,77 @@ function compileToBytecode(code) {
     }
     proc.addListener("error", (err) => logErr(err));
     proc.on("error", (err) => reject(err));
-    proc.on("exit", () => resolve2(data));
+    proc.on("exit", () => resolve(data));
   });
 }
 function convertArrowToFunction(code) {
   const result = babel.transform(code, {
-    plugins: ["@babel/plugin-transform-arrow-functions"]
+    plugins: ["@babel/plugin-transform-arrow-functions", "@babel/plugin-transform-template-literals"]
   });
   return {
     code: result?.code || code,
     map: result?.map
   };
 }
-function escapeRegExpString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/[|{}()[\]^$+*?.]/g, "\\$&");
+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 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)));
+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 === "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 s ? {
+  return {
     code: s.toString(),
-    map: sourcemap ? s.generateMap({ hires: "boundary" }) : null
-  } : { code };
-}
-var decodeFn = "function(a,b){return String.fromCharCode.apply(0,a.map(function(x){return x-b}))}";
-function obfuscateString(input) {
-  const offset = Math.random() << 4 | 0;
-  const hexArray = input.split("").map((c) => "0x" + (c.charCodeAt(0) + offset).toString(16));
-  return `(${decodeFn})(${JSON.stringify(hexArray)},${offset})`;
+    map: sourcemap ? s.generateMap({ hires: true }) : void 0
+  };
 }
 
 // src/build-plugins/utils.ts
@@ -179,11 +219,11 @@ async function buildAsar({
   rendererDistPath,
   generateGzipFile
 }) {
-  renameSync(rendererDistPath, join(electronDistPath, "renderer"));
-  writeFileSync(join(electronDistPath, "version"), version);
+  fs3.renameSync(rendererDistPath, path5.join(electronDistPath, "renderer"));
+  fs3.writeFileSync(path5.join(electronDistPath, "version"), version);
   await Asar.createPackage(electronDistPath, asarOutputPath);
-  const buf = await generateGzipFile(readFileSync(asarOutputPath));
-  writeFileSync(gzipPath, buf);
+  const buf = await generateGzipFile(fs3.readFileSync(asarOutputPath));
+  fs3.writeFileSync(gzipPath, buf);
   log.info(`build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
   return buf;
 }
@@ -206,9 +246,9 @@ async function buildVersion({
     signature: "",
     version
   };
-  if (existsSync(versionPath)) {
+  if (fs3.existsSync(versionPath)) {
     try {
-      const oldVersionJson = JSON.parse(readFileSync(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(fs3.readFileSync(versionPath, "utf-8"));
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
@@ -222,7 +262,7 @@ async function buildVersion({
   if (!isUpdateJSON(_json)) {
     throw new Error("invalid version info");
   }
-  writeFileSync(versionPath, JSON.stringify(_json, null, 2));
+  fs3.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
   log.info(`build version info to '${versionPath}'`, { timestamp: true });
 }
 async function buildEntry({
@@ -232,7 +272,7 @@ async function buildEntry({
   entryOutputDirPath,
   nativeModuleEntryMap,
   overrideEsbuildOptions
-}, define, protectedStrings) {
+}, define, bytecodeOptions) {
   const option = mergeConfig(
     {
       entryPoints: {
@@ -257,13 +297,13 @@ async function buildEntry({
     overrideEsbuildOptions ?? {}
   );
   const { metafile } = await build(option);
-  if (protectedStrings === void 0) {
+  if (!bytecodeOptions || !bytecodeOptions.enable) {
     return;
   }
   const filePaths = Object.keys(metafile?.outputs ?? []);
   for (const filePath of filePaths) {
-    let code = readFileSync(filePath, "utf-8");
-    const fileName = basename(filePath);
+    let code = fs3.readFileSync(filePath, "utf-8");
+    const fileName = path5.basename(filePath);
     const isEntry = fileName.endsWith("entry.js");
     if (isEntry) {
       code = code.replace(
@@ -271,16 +311,19 @@ async function buildEntry({
         (_, cert) => `"${cert.slice(1, -1).replace(/\n/g, "\\n")}"`
       );
     }
-    const transformedCode = convertString(
-      convertArrowToFunction(code).code,
-      [...protectedStrings, ...isEntry ? getCert(code) : []]
-    ).code;
+    let transformedCode = convertLiteral(convertArrowToFunction(code).code).code;
+    if (bytecodeOptions.beforeCompile) {
+      const result = await bytecodeOptions.beforeCompile(transformedCode, filePath);
+      if (result) {
+        transformedCode = result;
+      }
+    }
     const buffer = await compileToBytecode(transformedCode);
-    writeFileSync(`${filePath}c`, buffer);
-    writeFileSync(
+    fs3.writeFileSync(
       filePath,
       `${isEntry ? bytecodeModuleLoaderCode : useStrict}${isEntry ? "" : "module.exports = "}require("./${fileName}c")`
     );
+    fs3.writeFileSync(`${filePath}c`, buffer);
     bytecodeLog.info(
       `${filePath} [${(buffer.byteLength / 1e3).toFixed(2)} kB]`,
       { timestamp: true }
@@ -288,49 +331,45 @@ async function buildEntry({
   }
   bytecodeLog.info(`${filePaths.length} file${filePaths.length > 1 ? "s" : ""} compiled into bytecode`, { timestamp: true });
 }
-function getCert(code) {
-  const cert = code.match(/-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n/)?.[0];
-  return cert ? [cert] : [];
-}
 async function defaultZipFile(buffer) {
-  return new Promise((resolve2, reject) => {
-    brotliCompress(buffer, (err, buffer2) => {
+  return new Promise((resolve, reject) => {
+    zlib.brotliCompress(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       } else {
-        resolve2(buffer2);
+        resolve(buffer2);
       }
     });
   });
 }
 function hashBuffer(data, length) {
-  const hash = createHash("SHA256").update(data).digest("binary");
+  const hash = crypto.createHash("SHA256").update(data).digest("binary");
   return Buffer.from(hash).subarray(0, length);
 }
 function aesEncrypt(plainText, key, iv) {
-  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
   return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
 }
 function defaultSignature(buffer, privateKey, cert, version) {
-  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  const sig = crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64");
   return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
 }
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = dirname(privateKeyPath);
-  if (!existsSync(privateKeyDir)) {
-    mkdirSync(privateKeyDir, { recursive: true });
+  const privateKeyDir = path5.dirname(privateKeyPath);
+  if (!fs3.existsSync(privateKeyDir)) {
+    fs3.mkdirSync(privateKeyDir, { recursive: true });
   }
-  const certDir = dirname(certPath);
-  if (!existsSync(certDir)) {
-    mkdirSync(certDir, { recursive: true });
+  const certDir = path5.dirname(certPath);
+  if (!fs3.existsSync(certDir)) {
+    fs3.mkdirSync(certDir, { recursive: true });
   }
   const { cert, private: privateKey } = generate(subject, {
     keySize: keyLength,
     algorithm: "sha256",
     days
   });
-  writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
+  fs3.writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  fs3.writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
 }
 function parseKeys({
   keyLength,
@@ -339,22 +378,22 @@ function parseKeys({
   subject,
   days
 }) {
-  const keysDir = 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 (!existsSync(keysDir)) {
-    mkdirSync(keysDir);
+  if (!fs3.existsSync(keysDir)) {
+    fs3.mkdirSync(keysDir);
   }
-  if (!existsSync(privateKeyPath) || !existsSync(certPath)) {
+  if (!fs3.existsSync(privateKeyPath) || !fs3.existsSync(certPath)) {
     log.info("no key pair found, generate new key pair", { timestamp: true });
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  privateKey = readFileSync(privateKeyPath, "utf-8");
-  cert = readFileSync(certPath, "utf-8");
+  privateKey = fs3.readFileSync(privateKeyPath, "utf-8");
+  cert = fs3.readFileSync(certPath, "utf-8");
   return { privateKey, cert };
 }
 function parseSubjects(subject) {
@@ -433,15 +472,16 @@ function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
   };
   return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert };
 }
-function bytecodePlugin(enable, env, options = {}) {
+function bytecodePlugin(env, options) {
+  const {
+    enable,
+    preload = false,
+    beforeCompile
+  } = options;
   if (!enable) {
     return null;
   }
-  const {
-    protectedStrings = [],
-    enablePreload = false
-  } = options;
-  if (!enablePreload && env === "preload") {
+  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;
   }
@@ -457,10 +497,9 @@ function bytecodePlugin(enable, env, options = {}) {
       config = resolvedConfig;
     },
     transform(code, id2) {
-      if (protectedStrings.length === 0 || !filter(id2)) {
-        return;
+      if (!filter(id2)) {
+        return convertLiteral(code, !!config.build.sourcemap);
       }
-      return convertString(code, protectedStrings, !!config.build.sourcemap);
     },
     generateBundle(options2) {
       if (options2.format !== "es" && bytecodeRequired) {
@@ -497,7 +536,7 @@ function bytecodePlugin(enable, env, options = {}) {
         (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 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;
       const getBytecodeLoaderBlock = (chunkFileName) => {
@@ -508,6 +547,12 @@ function bytecodePlugin(enable, env, options = {}) {
           const chunk = output[name];
           if (chunk.type === "chunk") {
             let _code = chunk.code;
+            if (beforeCompile) {
+              const cbResult = await beforeCompile(_code, chunk.fileName);
+              if (cbResult) {
+                _code = cbResult;
+              }
+            }
             if (bytecodeRE && _code.match(bytecodeRE)) {
               let match;
               const s = new MagicString(_code);
@@ -520,20 +565,20 @@ function bytecodePlugin(enable, env, options = {}) {
               }
               _code = s.toString();
             }
-            const chunkFilePath = path2.resolve(outDir, name);
+            const chunkFilePath = path5.resolve(outDir, name);
             if (bytecodeChunks.includes(name)) {
               const bytecodeBuffer = await compileToBytecode(_code);
-              fs.writeFileSync(path2.resolve(outDir, name + "c"), bytecodeBuffer);
+              fs3.writeFileSync(chunkFilePath + "c", bytecodeBuffer);
               if (chunk.isEntry) {
                 const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
-                const bytecodeModuleBlock = `require("./${path2.basename(name) + "c"}");`;
+                const bytecodeModuleBlock = `require("./${path5.basename(name) + "c"}");`;
                 const code = `${useStrict}
 ${bytecodeLoaderBlock}
 module.exports=${bytecodeModuleBlock}
 `;
-                fs.writeFileSync(chunkFilePath, code);
+                fs3.writeFileSync(chunkFilePath, code);
               } else {
-                fs.unlinkSync(chunkFilePath);
+                fs3.unlinkSync(chunkFilePath);
               }
               bytecodeFiles.push({ name: name + "c", size: bytecodeBuffer.length });
             } else {
@@ -560,14 +605,14 @@ module.exports=${bytecodeModuleBlock}
                 _code = hasBytecodeMoudle ? _code.replace(useStrict, `${useStrict}
 ${bytecodeLoaderBlock}`) : _code;
               }
-              fs.writeFileSync(chunkFilePath, _code);
+              fs3.writeFileSync(chunkFilePath, _code);
             }
           }
         })
       );
     },
     closeBundle() {
-      const outDir = `${normalizePath(path2.relative(config.root, path2.resolve(config.root, config.build.outDir)))}/`;
+      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)}]`,
@@ -589,9 +634,9 @@ function debugStartup(args) {
 function getMainFilePath(options) {
   let mainFilePath;
   if (typeof options === "string") {
-    mainFilePath = basename(options);
+    mainFilePath = path5.basename(options);
   } else if (Array.isArray(options)) {
-    mainFilePath = basename(options[0]);
+    mainFilePath = path5.basename(options[0]);
   } else {
     const name = options?.index ?? options?.main;
     if (!name) {
@@ -631,21 +676,18 @@ async function electronWithUpdater(options) {
     return void 0;
   }
   const _options = parseOptions(pkg, sourcemap, minify, updater);
-  const bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { protectedStrings: [] } : void 0;
-  if (bytecodeOptions) {
-    minify = false;
-  }
+  const bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
   try {
-    rmSync(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
-    rmSync(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
+    fs3.rmSync(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
+    fs3.rmSync(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
   } catch {
   }
   log.info(`remove old files`, { timestamp: true });
   const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = _options;
   const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
   sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = normalizePath(join(entryOutputDirPath, "entry.js"));
-  if (resolve(normalizePath(pkg.main)) !== 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 = {
@@ -661,20 +703,20 @@ async function electronWithUpdater(options) {
     await buildEntry(
       buildEntryOption,
       define,
-      isBuild ? bytecodeOptions?.protectedStrings : void 0
+      bytecodeOptions
     );
     log.info(`vite build entry to '${entryOutputDirPath}'`, { timestamp: true });
   };
   const _postBuild = postBuild ? async () => await postBuild({
     getPathFromEntryOutputDir(...paths) {
-      return join(entryOutputDirPath, ...paths);
+      return path5.join(entryOutputDirPath, ...paths);
     },
     copyToEntryOutputDir({ from, to, skipIfExist = true }) {
-      if (existsSync(from)) {
-        const target = join(entryOutputDirPath, to ?? basename(from));
-        if (!skipIfExist || !existsSync(target)) {
+      if (fs3.existsSync(from)) {
+        const target = path5.join(entryOutputDirPath, to ?? path5.basename(from));
+        if (!skipIfExist || !fs3.existsSync(target)) {
           try {
-            cpSync(from, target);
+            fs3.cpSync(from, target);
           } catch (error) {
             log.warn(`copy failed: ${error}`);
           }
@@ -685,7 +727,7 @@ async function electronWithUpdater(options) {
   };
   let isInit = false;
   const rollupOptions = {
-    external: (src) => src.startsWith("node:") || Object.keys("dependencies" in pkg ? pkg.dependencies : {}).includes(src),
+    external: (src) => src.startsWith("node:") || Object.keys("dependencies" in pkg ? pkg.dependencies : {}).includes(src) || src === "original-fs",
     treeshake: true
   };
   const electronPluginOptions = {
@@ -707,7 +749,7 @@ async function electronWithUpdater(options) {
         {
           plugins: [
             !isBuild && useNotBundle ? notBundle() : void 0,
-            bytecodeOptions && bytecodePlugin(!!bytecode, "main", bytecodeOptions)
+            bytecodeOptions && bytecodePlugin("main", bytecodeOptions)
           ],
           build: {
             sourcemap,
@@ -726,7 +768,7 @@ async function electronWithUpdater(options) {
       vite: mergeConfig(
         {
           plugins: [
-            bytecodeOptions && bytecodePlugin(!!bytecode, "preload", bytecodeOptions),
+            bytecodeOptions && bytecodePlugin("preload", bytecodeOptions),
             {
               name: `${id}-build`,
               enforce: "post",
@@ -772,7 +814,10 @@ async function electronWithUpdater(options) {
   }
   let extraHmrPlugin;
   if (nativeModuleEntryMap) {
-    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath(file)));
+    const files = [
+      ...Object.values(nativeModuleEntryMap),
+      appEntryPath
+    ].map((file) => path5.resolve(normalizePath(file)));
     extraHmrPlugin = {
       name: `${id}-dev`,
       apply() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "electron-incremental-update",
   "type": "module",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.8",
   "description": "electron incremental update tools, powered by vite",
   "author": "subframe7536",
   "license": "MIT",
@@ -45,6 +45,7 @@
     "build": "tsup && esno fix-module.cjs",
     "release": "pnpm test && pnpm run build && bumpp --all && npm publish",
     "test": "vitest --run",
+    "test:dev": "vitest",
     "format": "eslint . --fix"
   },
   "publishConfig": {
@@ -53,27 +54,28 @@
   },
   "peerDependencies": {
     "@electron/asar": "*",
-    "esbuild": "*",
-    "magic-string": "*"
+    "esbuild": "*"
   },
   "dependencies": {
-    "@babel/core": "^7.24.7",
+    "@babel/core": "^7.24.9",
     "@babel/plugin-transform-arrow-functions": "^7.24.7",
+    "@babel/plugin-transform-template-literals": "^7.24.7",
     "@subframe7536/type-utils": "^0.1.6",
     "ci-info": "^4.0.0",
     "local-pkg": "^0.5.0",
+    "magic-string": "^0.30.10",
     "selfsigned": "^2.4.1",
     "vite-plugin-electron": "^0.28.7"
   },
   "devDependencies": {
-    "@subframe7536/eslint-config": "^0.7.2",
+    "@subframe7536/eslint-config": "^0.7.3",
     "@types/babel__core": "^7.20.5",
     "@types/node": "^20.14.11",
     "bumpp": "^9.4.1",
     "electron": "28.2.10",
     "eslint": "^9.7.0",
     "esno": "^4.7.0",
-    "tsup": "^8.1.0",
+    "tsup": "^8.2.1",
     "typescript": "^5.5.3",
     "vite": "^5.3.4",
     "vite-plugin-electron": "^0.28.7",