electron-incremental-update 2.4.3 → 3.0.0-beta.2

package/dist/vite.mjs

@@ -0,0 +1,1222 @@
+import { builtinModules, createRequire } from "node:module";
+import * as babel from "@babel/core";
+import { getPackageInfoSync, loadPackageJSON, loadPackageJSONSync } from "local-pkg";
+import MagicString from "magic-string";
+import cp from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { build, createFilter, createLogger, mergeConfig, normalizePath, version } from "vite";
+import { isCI } from "ci-info";
+import { createPackage } from "@electron/asar";
+import crypto from "node:crypto";
+import zlib from "node:zlib";
+import { generate } from "selfsigned";
+
+//#region src/utils/version.ts
+/**
+* Parse version string to {@link Version}, like `0.2.0-beta.1`
+* @param version version string
+*/
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
+	if (!match) throw new TypeError(`invalid version: ${version}`);
+	const [major, minor, patch] = match.slice(1, 4).map(Number);
+	const ret = {
+		major,
+		minor,
+		patch,
+		stage: "",
+		stageVersion: -1
+	};
+	if (match[4]) {
+		let [stage, _v] = match[4].split(".");
+		ret.stage = stage;
+		ret.stageVersion = Number(_v) || -1;
+	}
+	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) throw new TypeError(`Invalid version: ${version}`);
+	return ret;
+}
+const is = (j) => !!(j && j.minimumVersion && j.signature && j.version);
+/**
+* Check is `UpdateJSON`
+* @param json any variable
+*/
+function isUpdateJSON(json) {
+	return is(json) && is(json?.beta);
+}
+/**
+* Default function to generate `UpdateJSON`
+* @param existingJson exising update json
+* @param signature sigature
+* @param version target version
+* @param minimumVersion minimum version
+*/
+function defaultVersionJsonGenerator(existingJson, signature, version, minimumVersion) {
+	existingJson.beta = {
+		version,
+		minimumVersion,
+		signature
+	};
+	if (!parseVersion(version).stage) {
+		existingJson.version = version;
+		existingJson.minimumVersion = minimumVersion;
+		existingJson.signature = signature;
+	}
+	return existingJson;
+}
+
+//#endregion
+//#region src/vite/constant.ts
+const id = "electron-incremental-updater";
+const bytecodeId = `${id}-bytecode`;
+const esmId = `${id}-esm`;
+const log = createLogger("info", { prefix: `[${id}]` });
+const bytecodeLog = createLogger("info", { prefix: `[${bytecodeId}]` });
+
+//#endregion
+//#region src/vite/bytecode/code.ts
+const 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";
+const bytecodeModuleLoaderCode = "\"use strict\";\nconst fs = require(\"fs\");\nconst path = require(\"path\");\nconst vm = require(\"vm\");\nconst v8 = require(\"v8\");\nconst Module = require(\"module\");\nv8.setFlagsFromString(\"--no-lazy\");\nv8.setFlagsFromString(\"--no-flush-bytecode\");\nconst FLAG_HASH_OFFSET = 12;\nconst SOURCE_HASH_OFFSET = 8;\nlet dummyBytecode;\nfunction setFlagHashHeader(bytecodeBuffer) {\n  if (!dummyBytecode) {\n    const script = new vm.Script(\"\", {\n      produceCachedData: true\n    });\n    dummyBytecode = script.createCachedData();\n  }\n  dummyBytecode.slice(FLAG_HASH_OFFSET, FLAG_HASH_OFFSET + 4).copy(bytecodeBuffer, FLAG_HASH_OFFSET);\n};\nfunction getSourceHashHeader(bytecodeBuffer) {\n  return bytecodeBuffer.slice(SOURCE_HASH_OFFSET, SOURCE_HASH_OFFSET + 4);\n};\nfunction buffer2Number(buffer) {\n  let ret = 0;\n  ret |= buffer[3] << 24;\n  ret |= buffer[2] << 16;\n  ret |= buffer[1] << 8;\n  ret |= buffer[0];\n  return ret;\n};\nModule._extensions[\".jsc\"] = Module._extensions[\".cjsc\"] = function (module, filename) {\n  const bytecodeBuffer = fs.readFileSync(filename);\n  if (!Buffer.isBuffer(bytecodeBuffer)) {\n    throw new Error(\"BytecodeBuffer must be a buffer object.\");\n  }\n  setFlagHashHeader(bytecodeBuffer);\n  const length = buffer2Number(getSourceHashHeader(bytecodeBuffer));\n  let dummyCode = \"\";\n  if (length > 1) {\n    dummyCode = \"\\\"\" + \"\\u200b\".repeat(length - 2) + \"\\\"\";\n  }\n  const script = new vm.Script(dummyCode, {\n    filename: filename,\n    lineOffset: 0,\n    displayErrors: true,\n    cachedData: bytecodeBuffer\n  });\n  if (script.cachedDataRejected) {\n    throw new Error(\"Invalid or incompatible cached data (cachedDataRejected)\");\n  }\n  const require = function (id) {\n    return module.require(id);\n  };\n  require.resolve = function (request, options) {\n    return Module._resolveFilename(request, module, false, options);\n  };\n  if (process.mainModule) {\n    require.main = process.mainModule;\n  }\n  require.extensions = Module._extensions;\n  require.cache = Module._cache;\n  const compiledWrapper = script.runInThisContext({\n    filename: filename,\n    lineOffset: 0,\n    columnOffset: 0,\n    displayErrors: true\n  });\n  const dirname = path.dirname(filename);\n  const args = [module.exports, require, module, filename, dirname, process, global];\n  return compiledWrapper.apply(module.exports, args);\n};\n";
+
+//#endregion
+//#region src/vite/bytecode/utils.ts
+const electronModule = getPackageInfoSync("electron");
+const electronMajorVersion = parseVersion(electronModule.version).major;
+const useStrict = "'use strict';";
+const bytecodeModuleLoader = "__loader__.js";
+function getElectronPath() {
+	const electronModulePath = electronModule.rootPath;
+	let electronExecPath = process.env.ELECTRON_EXEC_PATH || "";
+	if (!electronExecPath) {
+		if (!electronModulePath) throw new Error("Electron is not installed");
+		const pathFile = path.join(electronModulePath, "path.txt");
+		let executablePath;
+		if (fs.existsSync(pathFile)) executablePath = fs.readFileSync(pathFile, "utf-8");
+		if (executablePath) {
+			electronExecPath = path.join(electronModulePath, "dist", executablePath);
+			process.env.ELECTRON_EXEC_PATH = electronExecPath;
+		} else throw new Error("Electron executable file is not existed");
+	}
+	return electronExecPath;
+}
+function getBytecodeCompilerPath() {
+	const scriptPath = path.join(electronModule.rootPath, "EIU_bytenode.cjs");
+	if (!fs.existsSync(scriptPath)) fs.writeFileSync(scriptPath, bytecodeGeneratorScript);
+	return scriptPath;
+}
+function toRelativePath(filename, importer) {
+	const relPath = path.posix.relative(path.dirname(importer), filename);
+	return relPath.startsWith(".") ? relPath : `./${relPath}`;
+}
+const logErr = (...args) => bytecodeLog.error(args.join(" "), { timestamp: true });
+function compileToBytecode(code, electronPath = getElectronPath()) {
+	let data = Buffer.from([]);
+	const bytecodePath = getBytecodeCompilerPath();
+	return new Promise((resolve, reject) => {
+		const proc = cp.spawn(electronPath, [bytecodePath], {
+			env: { ELECTRON_RUN_AS_NODE: "1" },
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		if (proc.stdin) {
+			proc.stdin.write(code);
+			proc.stdin.end();
+		}
+		if (proc.stdout) {
+			proc.stdout.on("data", (chunk) => data = Buffer.concat([data, chunk]));
+			proc.stdout.on("error", (err) => logErr(err));
+			proc.stdout.on("end", () => resolve(data));
+		}
+		if (proc.stderr) {
+			proc.stderr.on("data", (chunk) => logErr("Error: ", chunk.toString()));
+			proc.stderr.on("error", (err) => logErr("Error: ", err));
+		}
+		proc.addListener("error", (err) => logErr(err));
+		proc.on("error", (err) => reject(err));
+		proc.on("exit", () => resolve(data));
+	});
+}
+function convertArrowFunctionAndTemplate(code) {
+	const result = babel.transform(code, { plugins: ["@babel/plugin-transform-arrow-functions", "@babel/plugin-transform-template-literals"] });
+	return {
+		code: result?.code || code,
+		map: result?.map
+	};
+}
+const 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) {
+	return `_0xstr_([${input.split("").map((c) => `0x${(c.charCodeAt(0) + offset).toString(16)}`).join(",")}],${offset})`;
+}
+/**
+* Obfuscate string
+* @param code source code
+* @param sourcemap whether to generate sourcemap
+* @param offset custom offset
+*/
+function convertLiteral(code, sourcemap, offset) {
+	const s = new MagicString(code);
+	let hasTransformed = false;
+	const ast = babel.parse(code, { ast: true });
+	if (!ast) throw new Error("Cannot parse code");
+	babel.traverse(ast, { StringLiteral(path) {
+		const parent = path.parent;
+		const node = path.node;
+		if (parent.type === "CallExpression") {
+			if (parent.callee.type === "Identifier" && parent.callee.name === "require") return;
+			if (parent.callee.type === "Import") return;
+		}
+		if (parent.type.startsWith("Export")) return;
+		if (parent.type.startsWith("Import")) return;
+		if (parent.type === "ObjectMethod" && parent.key === node) return;
+		if (parent.type === "ObjectProperty" && parent.key === node) {
+			const result = `[${obfuscateString(node.value, offset)}]`;
+			const start = node.start;
+			const end = node.end;
+			if (start && end) {
+				s.overwrite(start, end, result);
+				hasTransformed = true;
+			}
+			return;
+		}
+		if (!node.value.trim()) return;
+		const result = obfuscateString(node.value, offset);
+		const start = node.start;
+		const end = node.end;
+		if (start && end) {
+			s.overwrite(start, end, result);
+			hasTransformed = true;
+		}
+	} });
+	if (hasTransformed) s.append("\n").append(decodeFn);
+	return {
+		code: s.toString(),
+		map: sourcemap ? s.generateMap({ hires: true }) : void 0
+	};
+}
+
+//#endregion
+//#region src/vite/utils.ts
+function readableSize(size) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	let i = 0;
+	while (size >= 1024 && i < units.length - 1) {
+		size /= 1024;
+		i++;
+	}
+	return `${size.toFixed(2)} ${units[i]}`;
+}
+function copyAndSkipIfExist(from, to, skipIfExist) {
+	if (!skipIfExist || !fs.existsSync(to)) try {
+		fs.cpSync(from, to, { recursive: true });
+	} catch (error) {
+		log.warn(`Copy failed: ${error}`, { timestamp: true });
+	}
+}
+function resolveInputToArray(files) {
+	if (typeof files === "string") return [files];
+	if (Array.isArray(files)) return files;
+	return Object.values(files);
+}
+
+//#endregion
+//#region src/vite/bytecode/index.ts
+function getBytecodeLoaderBlock(chunkFileName) {
+	return `require("${toRelativePath(bytecodeModuleLoader, normalizePath(chunkFileName))}");`;
+}
+/**
+* Compile to v8 bytecode to protect source code.
+*/
+function bytecodePlugin(env, options) {
+	const { enable, preload = false, electronPath, beforeCompile } = options;
+	if (!enable) return null;
+	if (!preload && env === "preload") {
+		bytecodeLog.warn("`bytecodePlugin` is skiped in preload. To enable in preload, please manually set the \"enablePreload\" option to true and set `sandbox: false` when creating the window", { timestamp: true });
+		return null;
+	}
+	const filter = createFilter(/\.(m?[jt]s|[jt]sx)$/);
+	let config;
+	let bytecodeRequired = false;
+	let bytecodeFiles = [];
+	return {
+		name: `${bytecodeId}-${env}`,
+		apply: "build",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		transform(code, id) {
+			if (!filter(id)) return convertLiteral(code, !!config.build.sourcemap);
+		},
+		generateBundle(options) {
+			if (options.format !== "es" && bytecodeRequired) this.emitFile({
+				type: "asset",
+				source: `${bytecodeModuleLoaderCode}\n`,
+				name: "Bytecode Loader File",
+				fileName: bytecodeModuleLoader
+			});
+		},
+		renderChunk(code, chunk, options) {
+			if (options.format === "es") {
+				bytecodeLog.warn("`bytecodePlugin` does not support ES module, please set \"build.rollupOptions.output.format\" option to \"cjs\"", { timestamp: true });
+				return null;
+			}
+			if (chunk.type === "chunk") {
+				bytecodeRequired = true;
+				return convertArrowFunctionAndTemplate(code);
+			}
+			return null;
+		},
+		async writeBundle(options, output) {
+			if (options.format === "es" || !bytecodeRequired) return;
+			const outDir = options.dir;
+			bytecodeFiles = [];
+			const bundles = Object.keys(output);
+			const chunks = Object.values(output).filter((chunk) => chunk.type === "chunk" && chunk.fileName !== bytecodeModuleLoader);
+			const bytecodeChunks = new Set(chunks.map((chunk) => chunk.fileName));
+			const pattern = chunks.filter((chunk) => !chunk.isEntry).map((chunk) => path.basename(chunk.fileName)).map((chunk) => `(${chunk})`).join("|");
+			const bytecodeRE = pattern ? new RegExp(`require\\(\\S*(?=(${pattern})\\S*\\))`, "g") : null;
+			await Promise.all(bundles.map(async (name) => {
+				const chunk = output[name];
+				if (chunk.type === "chunk") {
+					let _code = chunk.code;
+					const chunkFilePath = path.resolve(outDir, name);
+					if (beforeCompile) {
+						const cbResult = await beforeCompile(_code, chunkFilePath);
+						if (cbResult) _code = cbResult;
+					}
+					if (bytecodeRE && _code.match(bytecodeRE)) {
+						let match;
+						const s = new MagicString(_code);
+						while (match = bytecodeRE.exec(_code)) {
+							const [prefix, chunkName] = match;
+							const len = prefix.length + chunkName.length;
+							s.overwrite(match.index, match.index + len, `${prefix + chunkName}c`, { contentOnly: true });
+						}
+						_code = s.toString();
+					}
+					if (bytecodeChunks.has(name)) {
+						const bytecodeBuffer = await compileToBytecode(_code, electronPath);
+						fs.writeFileSync(`${chunkFilePath}c`, bytecodeBuffer);
+						if (chunk.isEntry) {
+							const code = `${useStrict}\n${getBytecodeLoaderBlock(chunk.fileName)}\nmodule.exports=${`require("./${`${path.basename(name)}c`}");`}\n`;
+							fs.writeFileSync(chunkFilePath, code);
+						} else fs.unlinkSync(chunkFilePath);
+						bytecodeFiles.push({
+							name: `${name}c`,
+							size: bytecodeBuffer.length
+						});
+					} else {
+						if (chunk.isEntry) {
+							let hasBytecodeMoudle = false;
+							const idsToHandle = new Set([...chunk.imports, ...chunk.dynamicImports]);
+							for (const moduleId of idsToHandle) {
+								if (bytecodeChunks.has(moduleId)) {
+									hasBytecodeMoudle = true;
+									break;
+								}
+								const moduleInfo = this.getModuleInfo(moduleId);
+								if (moduleInfo) {
+									const { importers, dynamicImporters } = moduleInfo;
+									for (const importerId of importers) idsToHandle.add(importerId);
+									for (const importerId of dynamicImporters) idsToHandle.add(importerId);
+								}
+							}
+							const bytecodeLoaderBlock = getBytecodeLoaderBlock(chunk.fileName);
+							_code = hasBytecodeMoudle ? _code.replace(new RegExp(`(${useStrict})|("use strict";)`), `${useStrict}\n${bytecodeLoaderBlock}`) : _code;
+						}
+						fs.writeFileSync(chunkFilePath, _code);
+					}
+				}
+			}));
+		},
+		closeBundle() {
+			const outDir = `${normalizePath(path.relative(config.root, path.resolve(config.root, config.build.outDir)))}/`;
+			bytecodeFiles.forEach((file) => {
+				bytecodeLog.info(`${outDir}${file.name} [${readableSize(file.size)}]`, { timestamp: true });
+			});
+			bytecodeLog.info(`${bytecodeFiles.length} bundles compiled into bytecode.`, { timestamp: true });
+			bytecodeFiles = [];
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/electron/utils.ts
+/** Resolve the default Vite's `InlineConfig` for build Electron-Main */
+function resolveViteConfig(options) {
+	const esmodule = (loadPackageJSONSync() ?? {}).type === "module";
+	return mergeConfig({
+		configFile: false,
+		publicDir: false,
+		build: {
+			lib: options.entry && {
+				entry: options.entry,
+				formats: esmodule ? ["es"] : ["cjs"],
+				fileName: () => "[name].js"
+			},
+			outDir: "dist-electron",
+			emptyOutDir: false
+		},
+		resolve: {
+			conditions: ["node"],
+			mainFields: [
+				"module",
+				"jsnext:main",
+				"jsnext"
+			]
+		},
+		define: { "process.env": "process.env" }
+	}, options?.vite || {});
+}
+function withExternalBuiltins(config) {
+	const builtins = builtinModules.filter((e) => !e.startsWith("_"));
+	builtins.push("electron", ...builtins.map((m) => `node:${m}`));
+	config.build ??= {};
+	config.build.rolldownOptions ??= {};
+	let external = config.build.rolldownOptions.external;
+	if (Array.isArray(external) || typeof external === "string" || external instanceof RegExp) external = builtins.concat(external);
+	else if (typeof external === "function") {
+		const original = external;
+		external = function(source, importer, isResolved) {
+			if (builtins.includes(source)) return true;
+			return original(source, importer, isResolved);
+		};
+	} else external = builtins;
+	config.build.rolldownOptions.external = external;
+	return config;
+}
+/**
+* @see https://github.com/vitejs/vite/blob/v4.0.1/packages/vite/src/node/constants.ts#L137-L147
+*/
+function resolveHostname(hostname) {
+	const loopbackHosts = new Set([
+		"localhost",
+		"127.0.0.1",
+		"::1",
+		"0000:0000:0000:0000:0000:0000:0000:0001"
+	]);
+	const wildcardHosts = new Set([
+		"0.0.0.0",
+		"::",
+		"0000:0000:0000:0000:0000:0000:0000:0000"
+	]);
+	return loopbackHosts.has(hostname) || wildcardHosts.has(hostname) ? "localhost" : hostname;
+}
+function resolveServerUrl(server) {
+	const addressInfo = server.httpServer?.address();
+	const isAddressInfo = (x) => x?.address;
+	if (isAddressInfo(addressInfo)) {
+		const { address, port } = addressInfo;
+		const hostname = resolveHostname(address);
+		const options = server.config.server;
+		const protocol = options.https ? "https" : "http";
+		const devBase = server.config.base;
+		const path = typeof options.open === "string" ? options.open : devBase;
+		return path.startsWith("http") ? path : `${protocol}://${hostname}:${port}${path}`;
+	}
+}
+/** @see https://github.com/vitejs/vite/blob/v5.4.9/packages/vite/src/node/build.ts#L489-L504 */
+function resolveInput(config) {
+	const options = config.build;
+	const { root } = config;
+	const libOptions = options.lib;
+	const resolve = (p) => path.resolve(root, p);
+	const input = libOptions ? options.rolldownOptions?.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(Object.entries(libOptions.entry).map(([alias, file]) => [alias, resolve(file)]))) : options.rolldownOptions?.input;
+	if (input) return input;
+	const indexHtml = resolve("index.html");
+	return fs.existsSync(indexHtml) ? indexHtml : void 0;
+}
+/**
+* When run the `vite build` command, there must be an entry file.
+* If the user does not need Renderer, we need to create a temporary entry file to avoid Vite throw error.
+* @see https://github.com/vitejs/vite/blob/v5.4.9/packages/vite/src/node/config.ts#L1234-L1236
+*/
+async function mockIndexHtml(config) {
+	const { root, build } = config;
+	const output = path.resolve(root, build.outDir);
+	const content = `
+<!doctype html>
+<html lang="en">
+  <head>
+    <title>vite-plugin-electron</title>
+  </head>
+  <body>
+    <div>An entry file for electron renderer process.</div>
+  </body>
+</html>
+`.trim();
+	const index = "index.html";
+	const filepath = path.join(root, index);
+	const distpath = path.join(output, index);
+	await fs.promises.writeFile(filepath, content);
+	return {
+		async remove() {
+			await fs.promises.unlink(filepath);
+			await fs.promises.unlink(distpath);
+		},
+		filepath,
+		distpath
+	};
+}
+/**
+* Inspired `tree-kill`, implemented based on sync-api. #168
+* @see https://github.com/pkrumins/node-tree-kill/blob/v1.2.2/index.js
+*/
+function treeKillSync(pid) {
+	if (process.platform === "win32") cp.execSync(`taskkill /pid ${pid} /T /F`);
+	else killTree(pidTree({
+		pid,
+		ppid: process.pid
+	}));
+}
+function pidTree(tree) {
+	const command = process.platform === "darwin" ? `pgrep -P ${tree.pid}` : `ps -o pid --no-headers --ppid ${tree.ppid}`;
+	try {
+		const childs = cp.execSync(command, { encoding: "utf8" }).match(/\d+/g)?.map((id) => +id);
+		if (childs) tree.children = childs.map((cid) => pidTree({
+			pid: cid,
+			ppid: tree.pid
+		}));
+	} catch {}
+	return tree;
+}
+function killTree(tree) {
+	if (tree.children) for (const child of tree.children) killTree(child);
+	try {
+		process.kill(tree.pid);
+	} catch {}
+}
+
+//#endregion
+//#region src/vite/electron/core.ts
+function build$1(options) {
+	return build(withExternalBuiltins(resolveViteConfig(options)));
+}
+function electron(options) {
+	const optionsArray = Array.isArray(options) ? options : [options];
+	let userConfig;
+	let configEnv;
+	let mockdInput;
+	if (!version.startsWith("8.")) throw new Error(`[vite-plugin-electron] Vite v${version} does not support \`rolldownOptions\`, please install \`vite@>=8\` or use an earlier version of \`vite-plugin-electron\`.`);
+	return [{
+		name: "vite-plugin-electron:dev",
+		apply: "serve",
+		configureServer(server) {
+			server.httpServer?.once("listening", () => {
+				Object.assign(process.env, { VITE_DEV_SERVER_URL: resolveServerUrl(server) });
+				const entryCount = optionsArray.length;
+				let closeBundleCount = 0;
+				for (const options of optionsArray) {
+					options.vite ??= {};
+					options.vite.mode ??= server.config.mode;
+					options.vite.root ??= server.config.root;
+					options.vite.envDir ??= server.config.envDir;
+					options.vite.envPrefix ??= server.config.envPrefix;
+					options.vite.build ??= {};
+					if (!Object.keys(options.vite.build).includes("watch")) options.vite.build.watch = {};
+					options.vite.build.minify ??= false;
+					options.vite.plugins ??= [];
+					options.vite.plugins.push({
+						name: ":startup",
+						closeBundle() {
+							if (++closeBundleCount < entryCount) return;
+							if (options.onstart) options.onstart.call(this, {
+								startup,
+								reload() {
+									if (process.electronApp) {
+										(server.hot || server.ws).send({ type: "full-reload" });
+										startup.send("electron-vite&type=hot-reload");
+									} else startup();
+								}
+							});
+							else startup();
+						}
+					});
+					build$1(options);
+				}
+			});
+		}
+	}, {
+		name: "vite-plugin-electron:prod",
+		apply: "build",
+		config(config, env) {
+			userConfig = config;
+			configEnv = env;
+			config.base ??= "./";
+		},
+		async configResolved(config) {
+			if (resolveInput(config) == null) mockdInput = await mockIndexHtml(config);
+		},
+		async closeBundle() {
+			mockdInput?.remove();
+			for (const options of optionsArray) {
+				options.vite ??= {};
+				options.vite.mode ??= configEnv.mode;
+				options.vite.root ??= userConfig.root;
+				options.vite.envDir ??= userConfig.envDir;
+				options.vite.envPrefix ??= userConfig.envPrefix;
+				await build$1(options);
+			}
+		}
+	}];
+}
+/**
+* Electron App startup function.
+* It will mount the Electron App child-process to `process.electronApp`.
+* @param argv default value `['.', '--no-sandbox']`
+* @param options options for `child_process.spawn`
+* @param customElectronPkg custom electron package name (default: 'electron')
+*/
+const startup = async (argv = [".", "--no-sandbox"], options, customElectronPkg) => {
+	const { spawn } = await import("node:child_process");
+	const electron = await import(customElectronPkg ?? "electron");
+	const electronPath = electron.default ?? electron;
+	await startup.exit();
+	const stdio = process.platform === "linux" ? [
+		"inherit",
+		"inherit",
+		"inherit",
+		"ignore",
+		"ipc"
+	] : [
+		"inherit",
+		"inherit",
+		"inherit",
+		"ipc"
+	];
+	process.electronApp = spawn(electronPath, argv, {
+		stdio,
+		...options
+	});
+	process.electronApp.once("exit", process.exit);
+	if (!startup.hookedProcessExit) {
+		startup.hookedProcessExit = true;
+		process.once("exit", startup.exit);
+	}
+};
+startup.send = (message) => {
+	if (process.electronApp) process.electronApp.send?.(message);
+};
+startup.hookedProcessExit = false;
+startup.exit = async () => {
+	if (process.electronApp) await new Promise((resolve) => {
+		process.electronApp.removeAllListeners();
+		process.electronApp.once("exit", resolve);
+		treeKillSync(process.electronApp.pid);
+	});
+};
+
+//#endregion
+//#region src/vite/build.ts
+async function buildAsar({ version, asarOutputPath, gzipPath, electronDistPath, rendererDistPath, generateGzipFile }) {
+	fs.renameSync(rendererDistPath, path.join(electronDistPath, "renderer"));
+	fs.writeFileSync(path.join(electronDistPath, "version"), version);
+	await createPackage(electronDistPath, asarOutputPath);
+	const buf = await generateGzipFile(fs.readFileSync(asarOutputPath));
+	fs.writeFileSync(gzipPath, buf);
+	log.info(`Build update asar to '${gzipPath}' [${readableSize(buf.length)}]`, { timestamp: true });
+	return buf;
+}
+async function buildUpdateJson({ versionPath, privateKey, cert, version, minimumVersion, generateSignature, generateUpdateJson }, asarBuffer) {
+	let _json = {
+		beta: {
+			minimumVersion: version,
+			signature: "",
+			version
+		},
+		minimumVersion: version,
+		signature: "",
+		version
+	};
+	if (fs.existsSync(versionPath)) try {
+		const oldVersionJson = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
+		if (isUpdateJSON(oldVersionJson)) _json = oldVersionJson;
+		else log.warn("Old version json is invalid, ignore it", { timestamp: true });
+	} catch {}
+	const sig = await generateSignature(asarBuffer, privateKey, cert, version);
+	_json = await generateUpdateJson(_json, sig, version, minimumVersion);
+	if (!isUpdateJSON(_json)) throw new Error("Invalid update json");
+	fs.writeFileSync(versionPath, JSON.stringify(_json, null, 2));
+	log.info(`build update json to '${versionPath}'`, { timestamp: true });
+}
+async function buildEntry({ sourcemap, minify, files, outDir, ignoreDynamicRequires, external, vite }, isESM, define, bytecodeOptions) {
+	await build$1({
+		entry: files,
+		vite: mergeConfig({
+			plugins: [bytecodeOptions && bytecodePlugin("main", bytecodeOptions)],
+			build: {
+				sourcemap,
+				minify,
+				outDir,
+				emptyOutDir: true,
+				rolldownOptions: {
+					external,
+					platform: "node",
+					output: {
+						polyfillRequire: false,
+						format: isESM ? "esm" : "cjs",
+						dynamicImportInCjs: !ignoreDynamicRequires
+					}
+				}
+			},
+			define
+		}, vite ?? {})
+	});
+}
+
+//#endregion
+//#region src/vite/electron/plugin.ts
+/**
+* @see https://github.com/vitejs/vite/blob/v4.4.7/packages/vite/src/node/utils.ts#L140
+*/
+const bareImportRE = /^(?![a-zA-Z]:)[\w@](?!.*:\/\/)/;
+const nodeModulesRE = /\/node_modules\//;
+/**
+* During dev, we exclude the `cjs` npm-pkg from bundle, mush like Vite :)
+*/
+function notBundle(options = {}) {
+	const externalIds = /* @__PURE__ */ new Set();
+	return {
+		name: "vite-plugin-electron:not-bundle",
+		enforce: "pre",
+		apply: "serve",
+		resolveId: {
+			filter: { id: bareImportRE },
+			async handler(source, importer) {
+				if (!importer || importer.includes("node_modules/")) return;
+				if (externalIds.has(source)) return {
+					id: source,
+					external: true
+				};
+				const id = (await this.resolve(source, importer, { skipSelf: true }))?.id;
+				if (!id || !nodeModulesRE.test(id) || options.filter?.(id) === false) return;
+				try {
+					createRequire(importer).resolve(source);
+				} catch {
+					return;
+				}
+				externalIds.add(source);
+				return {
+					id: source,
+					external: true,
+					moduleSideEffects: false
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/electron/simple.ts
+async function electronSimple(options) {
+	const flatApiOptions = [options.main];
+	const esmodule = (await loadPackageJSON() ?? {}).type === "module";
+	if (options.preload) {
+		const { input, vite: viteConfig = {}, ...preloadOptions } = options.preload;
+		const preload = {
+			onstart(args) {
+				args.reload();
+			},
+			...preloadOptions,
+			vite: mergeConfig({ build: { rolldownOptions: {
+				input,
+				output: {
+					format: "cjs",
+					inlineDynamicImports: true,
+					entryFileNames: `[name].${esmodule ? "mjs" : "js"}`,
+					chunkFileNames: `[name].${esmodule ? "mjs" : "js"}`,
+					assetFileNames: "[name].[ext]"
+				}
+			} } }, viteConfig)
+		};
+		flatApiOptions.push(preload);
+	}
+	return electron(flatApiOptions);
+}
+
+//#endregion
+//#region src/utils/crypto.ts
+function hashBuffer(data, length) {
+	const hash = crypto.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);
+	return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
+}
+/**
+* Default function to generate asar signature, returns generated signature
+* @param buffer file buffer
+* @param privateKey primary key
+* @param cert certificate
+* @param version target version
+*/
+function defaultSignature(buffer, privateKey, cert, version) {
+	return aesEncrypt(`${crypto.createSign("RSA-SHA256").update(buffer).sign(crypto.createPrivateKey(privateKey), "base64")}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
+}
+
+//#endregion
+//#region src/utils/zip.ts
+/**
+* Default function to compress file using brotli
+* @param buffer uncompressed file buffer
+*/
+async function defaultZipFile(buffer) {
+	return new Promise((resolve, reject) => {
+		zlib.brotliCompress(buffer, (err, buffer) => err ? reject(err) : resolve(buffer));
+	});
+}
+
+//#endregion
+//#region src/vite/key.ts
+async function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
+	const privateKeyDir = path.dirname(privateKeyPath);
+	if (!fs.existsSync(privateKeyDir)) fs.mkdirSync(privateKeyDir, { recursive: true });
+	const certDir = path.dirname(certPath);
+	if (!fs.existsSync(certDir)) fs.mkdirSync(certDir, { recursive: true });
+	const startDate = /* @__PURE__ */ new Date();
+	const endDate = new Date(startDate);
+	endDate.setDate(startDate.getDate() + days);
+	const { cert, private: privateKey } = await generate(subject, {
+		keySize: keyLength,
+		algorithm: "sha256",
+		notBeforeDate: startDate,
+		notAfterDate: endDate
+	});
+	fs.writeFileSync(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+	fs.writeFileSync(certPath, cert.replace(/\r\n?/g, "\n"));
+}
+async function parseKeys({ keyLength, privateKeyPath, certPath, subject, days }) {
+	const keysDir = path.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 (!fs.existsSync(keysDir)) fs.mkdirSync(keysDir);
+	if (!fs.existsSync(privateKeyPath) || !fs.existsSync(certPath)) {
+		log.info("No key pair found, generate new key pair", { timestamp: true });
+		await generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
+	}
+	privateKey = fs.readFileSync(privateKeyPath, "utf-8");
+	cert = fs.readFileSync(certPath, "utf-8");
+	return {
+		privateKey,
+		cert
+	};
+}
+function parseSubjects(subject) {
+	return Object.entries(subject).filter(([_, value]) => !!value).map(([name, value]) => ({
+		name,
+		value
+	}));
+}
+
+//#endregion
+//#region src/vite/option.ts
+async function parseOptions(isBuild, pkg, sourcemap = false, minify = false, entry = {}, options = {}) {
+	const { minify: entryMinify, sourcemap: entrySourcemap, outDir = "dist-entry", files = "electron/entry.ts", postBuild, ignoreDynamicRequires = false, external = [
+		/^node:.*/,
+		/.*\.(node|dll|dylib|so)$/,
+		"original-fs",
+		"electron",
+		...isBuild || postBuild ? [] : Object.keys("dependencies" in pkg ? pkg.dependencies : {})
+	], vite = {} } = entry;
+	const { minimumVersion = "0.0.0", paths: { asarOutputPath = `release/${pkg.name}.asar`, gzipPath = `release/${pkg.name}-${pkg.version}.asar.gz`, electronDistPath = "dist-electron", rendererDistPath = "dist", versionPath = "version.json" } = {}, keys: { privateKeyPath = "keys/private.pem", certPath = "keys/cert.pem", keyLength = 2048, certInfo: { subject = {
+		commonName: pkg.name,
+		organizationName: `org.${pkg.name}`
+	}, days = 3650 } = {} } = {}, overrideGenerator: { generateGzipFile = defaultZipFile, generateSignature = defaultSignature, generateUpdateJson = defaultVersionJsonGenerator } = {} } = options;
+	const buildAsarOption = {
+		version: pkg.version,
+		asarOutputPath,
+		gzipPath,
+		electronDistPath,
+		rendererDistPath,
+		generateGzipFile
+	};
+	const buildEntryOption = {
+		minify: entryMinify ?? minify,
+		sourcemap: entrySourcemap ?? sourcemap,
+		outDir,
+		files,
+		vite,
+		ignoreDynamicRequires,
+		external
+	};
+	const { privateKey, cert } = await parseKeys({
+		keyLength,
+		privateKeyPath,
+		certPath,
+		subject,
+		days
+	});
+	return {
+		buildAsarOption,
+		buildEntryOption,
+		buildVersionOption: {
+			version: pkg.version,
+			minimumVersion,
+			privateKey,
+			cert,
+			versionPath,
+			generateSignature,
+			generateUpdateJson
+		},
+		postBuild,
+		cert
+	};
+}
+
+//#endregion
+//#region src/vite/core.ts
+/**
+* Startup function for debug
+* @see {@link https://github.com/electron-vite/electron-vite-vue/blob/main/vite.config.ts electron-vite-vue template}
+* @example
+* import { debugStartup, buildElectronPluginOptions } from 'electron-incremental-update/vite'
+* const options = buildElectronPluginOptions({
+*   // ...
+*   main: {
+*     // ...
+*     startup: debugStartup
+*   },
+* })
+*/
+const debugStartup = async (args) => {
+	if (process.env.VSCODE_DEBUG) console.log("[startup] Electron App");
+	else await args.startup();
+};
+/**
+* Startup function to filter unwanted error message
+* @see {@link https://github.com/electron/electron/issues/46903#issuecomment-2848483520 reference}
+* @example
+* import { filterErrorMessageStartup, buildElectronPluginOptions } from 'electron-incremental-update/vite'
+* const options = buildElectronPluginOptions({
+*   // ...
+*   main: {
+*     // ...
+*     startup: args => filterErrorMessageStartup(
+*       args,
+*       // ignore error message when function returns false
+*       msg => !/"code":-32601/.test(msg)
+*     )
+*   },
+* })
+*/
+async function filterErrorMessageStartup(args, filter) {
+	const stdio = process.platform === "linux" ? [
+		"inherit",
+		"pipe",
+		"pipe",
+		"ignore",
+		"ipc"
+	] : [
+		"inherit",
+		"pipe",
+		"pipe",
+		"ipc"
+	];
+	await args.startup(void 0, { stdio });
+	const elec = process.electronApp;
+	elec.stdout.addListener("data", (data) => {
+		console.log(data.toString().trimEnd());
+	});
+	elec.stderr.addListener("data", (data) => {
+		const message = data.toString();
+		if (filter(message)) console.error(message);
+	});
+}
+/**
+* Startup function util to fix Windows terminal charset
+* @example
+* import { debugStartup, fixWinCharEncoding, buildElectronPluginOptions } from 'electron-incremental-update/vite'
+* const options = buildElectronPluginOptions({
+*   // ...
+*   main: {
+*     // ...
+*     startup: fixWinCharEncoding(debugStartup)
+*   },
+* })
+*/
+function fixWinCharEncoding(fn) {
+	return (async (...args) => {
+		if (process.platform === "win32") (await import("node:child_process")).spawnSync("chcp", ["65001"]);
+		await fn(...args);
+	});
+}
+function getMainFileBaseName(options) {
+	let mainFilePath;
+	if (typeof options === "string") mainFilePath = path.basename(options);
+	else if (Array.isArray(options)) mainFilePath = path.basename(options[0]);
+	else {
+		if (!(options?.index ?? options?.main)) throw new Error(`\`options.main.files\` (${options}) must have "index" or "main" key, like \`{ index: "./electron/main/index.ts" }\``);
+		mainFilePath = options?.index ? "index.js" : "main.js";
+	}
+	log.info(`Using "${mainFilePath}" as main file`, { timestamp: true });
+	return mainFilePath.replace(/\.[cm]?ts$/, ".js");
+}
+function parseVersionPath(versionPath) {
+	versionPath = normalizePath(versionPath);
+	if (!versionPath.startsWith("./")) versionPath = `./${versionPath}`;
+	return new URL(versionPath, "file://").pathname.slice(1);
+}
+/**
+* Base on `./electron/simple`
+* - integrate with updater
+* - no `renderer` config
+* - remove old output file
+* - externalize dependencies
+* - auto restart when entry file changes
+* - other configs in {@link https://github.com/electron-vite/electron-vite-vue/blob/main/vite.config.ts electron-vite-vue template}
+*
+* You can override all the vite configs, except output directories (use `options.updater.paths.electronDistPath` instead)
+*
+* @example
+* ```ts
+* import { defineConfig } from 'vite'
+* import { debugStartup, electronWithUpdater } from 'electron-incremental-update/vite'
+*
+* export default defineConfig(async ({ command }) => {
+*   const isBuild = command === 'build'
+*   return {
+*     plugins: [
+*       electronWithUpdater({
+*         isBuild,
+*         main: {
+*           files: ['./electron/main/index.ts', './electron/main/worker.ts'],
+*           // see https://github.com/electron-vite/electron-vite-vue/blob/85ed267c4851bf59f32888d766c0071661d4b94c/vite.config.ts#L22-L28
+*           onstart: debugStartup,
+*         },
+*         preload: {
+*           files: './electron/preload/index.ts',
+*         },
+*         updater: {
+*           // options
+*         }
+*       }),
+*     ],
+*     server: process.env.VSCODE_DEBUG && (() => {
+*       const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
+*       return {
+*         host: url.hostname,
+*         port: +url.port,
+*       }
+*     })(),
+*   }
+* })
+* ```
+*/
+async function electronWithUpdater(options) {
+	let { isBuild, entry: _entry, main: _main, preload: _preload, sourcemap = !isBuild, minify = isBuild, buildVersionJson, updater, bytecode, useNotBundle = true } = options;
+	const pkg = await loadPackageJSON();
+	if (!pkg || !pkg.version || !pkg.name || !pkg.main) {
+		log.error("package.json not found or invalid, must contains version, name and main field", { timestamp: true });
+		return;
+	}
+	const isESM = pkg.type === "module";
+	let bytecodeOptions = typeof bytecode === "object" ? bytecode : bytecode === true ? { enable: true } : void 0;
+	if (isESM && bytecodeOptions?.enable) throw new Error("`bytecodePlugin` does not support ES module, please remove \"type\": \"module\" in package.json");
+	const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild, cert } = await parseOptions(isBuild, pkg, sourcemap, minify, _entry, updater);
+	const { outDir: entryOutputDirPath, files, external } = buildEntryOption;
+	try {
+		fs.rmSync(buildAsarOption.electronDistPath, {
+			recursive: true,
+			force: true
+		});
+		fs.rmSync(entryOutputDirPath, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	log.info(`Clear cache files`, { timestamp: true });
+	sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
+	const _appPath = normalizePath(path.join(entryOutputDirPath, "entry.js"));
+	if (path.resolve(normalizePath(pkg.main)) !== path.resolve(_appPath)) throw new Error(`Wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
+	const define = {
+		__EIU_ASAR_BASE_NAME__: JSON.stringify(path.basename(buildAsarOption.asarOutputPath)),
+		__EIU_ELECTRON_DIST_PATH__: JSON.stringify(normalizePath(buildAsarOption.electronDistPath)),
+		__EIU_ENTRY_DIST_PATH__: JSON.stringify(normalizePath(buildEntryOption.outDir)),
+		__EIU_IS_DEV__: JSON.stringify(!isBuild),
+		__EIU_IS_ESM__: JSON.stringify(isESM),
+		__EIU_MAIN_FILE__: JSON.stringify(getMainFileBaseName(_main.files)),
+		__EIU_SIGNATURE_CERT__: JSON.stringify(cert),
+		__EIU_VERSION_PATH__: JSON.stringify(parseVersionPath(normalizePath(buildVersionOption.versionPath)))
+	};
+	async function _buildEntry() {
+		await buildEntry(buildEntryOption, isESM, define, bytecodeOptions);
+		log.info(`Build entry to '${entryOutputDirPath}'`, { timestamp: true });
+		await postBuild?.({
+			isBuild,
+			getPathFromEntryOutputDir(...paths) {
+				return path.join(entryOutputDirPath, ...paths);
+			},
+			copyToEntryOutputDir({ from, to = path.basename(from), skipIfExist = true }) {
+				if (!fs.existsSync(from)) {
+					log.warn(`${from} not found`, { timestamp: true });
+					return;
+				}
+				copyAndSkipIfExist(from, path.join(entryOutputDirPath, to), skipIfExist);
+			},
+			copyModules({ modules, skipIfExist = true }) {
+				const nodeModulesPath = path.join(entryOutputDirPath, "node_modules");
+				for (const m of modules) {
+					const { rootPath } = getPackageInfoSync(m) || {};
+					if (!rootPath) {
+						log.warn(`Package '${m}' not found`, { timestamp: true });
+						continue;
+					}
+					copyAndSkipIfExist(rootPath, path.join(nodeModulesPath, m), skipIfExist);
+				}
+			}
+		});
+	}
+	let isInit = false;
+	const result = [electronSimple({
+		main: {
+			entry: _main.files,
+			onstart: async (args) => {
+				if (!isInit) {
+					isInit = true;
+					await _buildEntry();
+				}
+				if (_main.onstart) await _main.onstart(args);
+				else await args.startup();
+			},
+			vite: mergeConfig({
+				plugins: [!isBuild && useNotBundle && notBundle(), bytecodeOptions && bytecodePlugin("main", bytecodeOptions)],
+				build: {
+					sourcemap,
+					minify,
+					outDir: `${buildAsarOption.electronDistPath}/main`,
+					rolldownOptions: {
+						external,
+						output: {
+							polyfillRequire: false,
+							format: isESM ? "esm" : "cjs"
+						}
+					}
+				},
+				define
+			}, _main.vite ?? {})
+		},
+		preload: {
+			input: _preload.files,
+			vite: mergeConfig({
+				plugins: [bytecodeOptions && bytecodePlugin("preload", bytecodeOptions), {
+					name: `${id}-build`,
+					enforce: "post",
+					apply() {
+						return isBuild;
+					},
+					async closeBundle() {
+						await _buildEntry();
+						const buffer = await buildAsar(buildAsarOption);
+						if (!buildVersionJson && !isCI) log.warn("No `buildVersionJson` option setup, skip build version json. Only build in CI by default", { timestamp: true });
+						else await buildUpdateJson(buildVersionOption, buffer);
+					}
+				}],
+				build: {
+					sourcemap: sourcemap ? "inline" : void 0,
+					minify,
+					outDir: `${buildAsarOption.electronDistPath}/preload`,
+					rolldownOptions: {
+						external,
+						output: { polyfillRequire: false }
+					}
+				},
+				define
+			}, _preload?.vite ?? {})
+		}
+	})];
+	if (files) {
+		const watchFiles = resolveInputToArray(files).map((file) => path.resolve(normalizePath(file)));
+		result.push({
+			name: `${id}-dev`,
+			apply() {
+				return !isBuild;
+			},
+			configureServer(server) {
+				server.watcher.add(watchFiles).on("change", async (p) => {
+					if (!watchFiles.includes(p)) return;
+					await _buildEntry();
+					if (_main.onstart) await _main.onstart({
+						startup,
+						reload: () => {
+							if (process.electronApp) {
+								(server.hot || server.ws).send({ type: "full-reload" });
+								startup.send("electron-vite&type=hot-reload");
+							} else startup();
+						}
+					});
+					else await startup();
+				});
+			}
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/vite/define.ts
+/**
+* Vite config helper
+* @see {@link electronWithUpdater}
+* @example
+* ```ts
+* import { defineElectronConfig } from 'electron-incremental-update/vite'
+*
+* export default defineElectronConfig({
+*   main: {
+*     files: ['./electron/main/index.ts', './electron/main/worker.ts'],
+*     // see https://github.com/electron-vite/electron-vite-vue/blob/85ed267c4851bf59f32888d766c0071661d4b94c/vite.config.ts#L22-L28
+*     onstart: debugStartup,
+*   },
+*   preload: {
+*     files: './electron/preload/index.ts',
+*   },
+*   updater: {
+*     // options
+*   },
+*   renderer: {
+*     server: process.env.VSCODE_DEBUG && (() => {
+*       const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
+*       return {
+*         host: url.hostname,
+*         port: +url.port,
+*       }
+*     })(),
+*   }
+* })
+* ```
+*/
+function defineElectronConfig(options) {
+	return ({ command }) => {
+		options.isBuild ??= command === "build";
+		const electronPlugin = electronWithUpdater(options);
+		const result = options.renderer ?? {};
+		result.plugins ??= [];
+		result.plugins.push(electronPlugin);
+		const rendererDistPath = options.updater?.paths?.rendererDistPath;
+		if (rendererDistPath) {
+			result.build ??= {};
+			result.build.outDir = rendererDistPath;
+		}
+		return result;
+	};
+}
+
+//#endregion
+export { convertLiteral, debugStartup, electronWithUpdater as default, electronWithUpdater, defineElectronConfig, filterErrorMessageStartup, fixWinCharEncoding };