electron-incremental-update 1.0.3 → 1.1.0

package/dist/vite.js

@@ -1,74 +1,41 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/vite.ts
-var vite_exports = {};
-__export(vite_exports, {
-  debugStartup: () => debugStartup,
-  electronWithUpdater: () => electronWithUpdater,
-  log: () => log
-});
-module.exports = __toCommonJS(vite_exports);
-var import_node_path3 = require("path");
-var import_node_fs4 = require("fs");
-var import_vite3 = require("vite");
-var import_simple = __toESM(require("vite-plugin-electron/simple"));
-var import_vite_plugin_electron = require("vite-plugin-electron");
-var import_plugin = require("vite-plugin-electron/plugin");
+import { basename as basename2, join as join2, resolve } from "node:path";
+import { cpSync, existsSync as existsSync4, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
+import { createLogger, mergeConfig, 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";
 
 // src/build-plugins/build.ts
-var import_promises = require("fs/promises");
-var import_node_fs2 = require("fs");
-var import_node_path = require("path");
-var import_asar = __toESM(require("@electron/asar"));
-var import_esbuild = require("esbuild");
+import { existsSync as existsSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join } from "node:path";
+import Asar from "@electron/asar";
+import { build } from "esbuild";
+import "vite";
+
+// src/crypto/utils.ts
+import { createHash } from "node:crypto";
+function hashString(data, length) {
+  const hash = createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
 
-// src/crypto.ts
-var import_node_crypto = require("crypto");
-function encrypt(plainText, key2, iv) {
-  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-cbc", key2, iv);
+// src/crypto/enc.ts
+import { createCipheriv, createPrivateKey, createSign } from "node:crypto";
+function encrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
   let encrypted = cipher.update(plainText, "utf8", "base64url");
   encrypted += cipher.final("base64url");
   return encrypted;
 }
-function key(data, length) {
-  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
-  return Buffer.from(hash).subarray(0, length);
-}
 var signature = (buffer, privateKey, cert, version) => {
-  const sig = (0, import_node_crypto.createSign)("RSA-SHA256").update(buffer).sign((0, import_node_crypto.createPrivateKey)(privateKey), "base64");
-  return encrypt(`${sig}%${version}`, key(cert, 32), key(buffer, 16));
+  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
 };
 
-// src/utils/noDep.ts
+// src/utils/pure.ts
 function parseVersion(version) {
-  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i;
   const match = semver.exec(version);
   if (!match) {
     throw new TypeError(`invalid version: ${version}`);
@@ -97,19 +64,19 @@ function isUpdateJSON(json) {
 }
 
 // src/utils/zip.ts
-var import_node_fs = require("fs");
-var import_node_zlib = require("zlib");
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { gunzip, gzip } from "node:zlib";
 async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs.existsSync)(filePath)) {
+  if (!existsSync(filePath)) {
     throw new Error(`path to be zipped not exist: ${filePath}`);
   }
-  const buffer = (0, import_node_fs.readFileSync)(filePath);
+  const buffer = readFileSync(filePath);
   return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.gzip)(buffer, (err, buffer2) => {
+    gzip(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       }
-      (0, import_node_fs.writeFileSync)(targetFilePath, buffer2);
+      writeFileSync(targetFilePath, buffer2);
       resolve2(null);
     });
   });
@@ -123,9 +90,9 @@ async function buildAsar({
   electronDistPath,
   rendererDistPath
 }) {
-  await (0, import_promises.rename)(rendererDistPath, (0, import_node_path.join)(electronDistPath, "renderer"));
-  await (0, import_promises.writeFile)((0, import_node_path.join)(electronDistPath, "version"), version);
-  await import_asar.default.createPackage(electronDistPath, asarOutputPath);
+  renameSync(rendererDistPath, join(electronDistPath, "renderer"));
+  writeFileSync2(join(electronDistPath, "version"), version);
+  await Asar.createPackage(electronDistPath, asarOutputPath);
   await zipFile(asarOutputPath, gzipPath);
 }
 async function buildVersion({
@@ -150,9 +117,9 @@ async function buildVersion({
     size: 0,
     version
   };
-  if ((0, import_node_fs2.existsSync)(versionPath)) {
+  if (existsSync2(versionPath)) {
     try {
-      const oldVersionJson = JSON.parse(await (0, import_promises.readFile)(versionPath, "utf-8"));
+      const oldVersionJson = JSON.parse(readFileSync2(versionPath, "utf-8"));
       if (isUpdateJSON(oldVersionJson)) {
         _json = oldVersionJson;
       } else {
@@ -161,7 +128,7 @@ async function buildVersion({
     } catch (error) {
     }
   }
-  const buffer = await (0, import_promises.readFile)(gzipPath);
+  const buffer = readFileSync2(gzipPath);
   const sig = await (generateSignature ?? signature)(buffer, privateKey, cert, version);
   if (generateVersionJson) {
     _json = await generateVersionJson(_json, buffer, sig, version, minimumVersion);
@@ -182,7 +149,7 @@ async function buildVersion({
       _json.size = buffer.length;
     }
   }
-  await (0, import_promises.writeFile)(versionPath, JSON.stringify(_json, null, 2));
+  writeFileSync2(versionPath, JSON.stringify(_json, null, 2));
 }
 async function buildEntry({
   sourcemap,
@@ -192,7 +159,7 @@ async function buildEntry({
   nativeModuleEntryMap,
   overrideEsbuildOptions
 }) {
-  await (0, import_esbuild.build)({
+  await build({
     entryPoints: {
       entry: appEntryPath,
       ...nativeModuleEntryMap
@@ -213,33 +180,33 @@ async function buildEntry({
 }
 
 // src/build-plugins/key.ts
-var import_node_fs3 = require("fs");
-var import_node_path2 = require("path");
-var import_selfsigned = require("selfsigned");
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname } from "node:path";
+import { generate } from "selfsigned";
 function generateKeyPair(keyLength, subject, days, privateKeyPath, certPath) {
-  const privateKeyDir = (0, import_node_path2.dirname)(privateKeyPath);
-  if (!(0, import_node_fs3.existsSync)(privateKeyDir)) {
-    (0, import_node_fs3.mkdirSync)(privateKeyDir, { recursive: true });
+  const privateKeyDir = dirname(privateKeyPath);
+  if (!existsSync3(privateKeyDir)) {
+    mkdirSync(privateKeyDir, { recursive: true });
   }
-  const certDir = (0, import_node_path2.dirname)(certPath);
-  if (!(0, import_node_fs3.existsSync)(certDir)) {
-    (0, import_node_fs3.mkdirSync)(certDir, { recursive: true });
+  const certDir = dirname(certPath);
+  if (!existsSync3(certDir)) {
+    mkdirSync(certDir, { recursive: true });
   }
-  const { cert, private: privateKey } = (0, import_selfsigned.generate)(subject, {
+  const { cert, private: privateKey } = generate(subject, {
     keySize: keyLength,
     algorithm: "sha256",
     days
   });
-  (0, import_node_fs3.writeFileSync)(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
-  (0, import_node_fs3.writeFileSync)(certPath, cert.replace(/\r\n?/g, "\n"));
+  writeFileSync3(privateKeyPath, privateKey.replace(/\r\n?/g, "\n"));
+  writeFileSync3(certPath, cert.replace(/\r\n?/g, "\n"));
 }
-var noCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)['"]{2}/m;
-var existCertRegex = /(?<=const SIGNATURE_CERT\s*=\s*)(['"]-----BEGIN CERTIFICATE-----[\s\S]*-----END CERTIFICATE-----\\n['"])/m;
+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 (!(0, import_node_fs3.existsSync)(entryPath)) {
+  if (!existsSync3(entryPath)) {
     throw new Error(`entry not exist: ${entryPath}`);
   }
-  const file = (0, import_node_fs3.readFileSync)(entryPath, "utf-8");
+  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)) {
@@ -249,7 +216,7 @@ function writeCertToEntry(entryPath, cert) {
   } else {
     throw new Error("no `SIGNATURE_CERT` found in entry");
   }
-  (0, import_node_fs3.writeFileSync)(entryPath, replaced);
+  writeFileSync3(entryPath, replaced);
 }
 function parseKeys({
   keyLength,
@@ -259,14 +226,14 @@ function parseKeys({
   subject,
   days
 }) {
-  const keysDir = (0, import_node_path2.dirname)(privateKeyPath);
-  !(0, import_node_fs3.existsSync)(keysDir) && (0, import_node_fs3.mkdirSync)(keysDir);
-  if (!(0, import_node_fs3.existsSync)(privateKeyPath) || !(0, import_node_fs3.existsSync)(certPath)) {
+  const keysDir = dirname(privateKeyPath);
+  !existsSync3(keysDir) && mkdirSync(keysDir);
+  if (!existsSync3(privateKeyPath) || !existsSync3(certPath)) {
     log.warn("no key pair found, generate new key pair");
     generateKeyPair(keyLength, parseSubjects(subject), days, privateKeyPath, certPath);
   }
-  const privateKey = process.env.UPDATER_PK || (0, import_node_fs3.readFileSync)(privateKeyPath, "utf-8");
-  const cert = process.env.UPDATER_CERT || (0, import_node_fs3.readFileSync)(certPath, "utf-8");
+  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 };
 }
@@ -275,12 +242,12 @@ function parseSubjects(subject) {
 }
 
 // src/build-plugins/option.ts
-function parseOptions(isBuild, pkg, options = {}) {
+function parseOptions(pkg, sourcemap = false, minify = false, options = {}) {
   const {
     minimumVersion = "0.0.0",
     entry: {
-      minify = isBuild,
-      sourcemap = isBuild,
+      minify: entryMinify,
+      sourcemap: entrySourcemap,
       entryOutputDirPath = "dist-entry",
       appEntryPath = "electron/entry.ts",
       nativeModuleEntryMap = {},
@@ -318,8 +285,8 @@ function parseOptions(isBuild, pkg, options = {}) {
     rendererDistPath
   };
   const buildEntryOption = {
-    minify,
-    sourcemap,
+    minify: entryMinify ?? minify,
+    sourcemap: entrySourcemap ?? sourcemap,
     entryOutputDirPath,
     appEntryPath,
     nativeModuleEntryMap,
@@ -346,59 +313,78 @@ function parseOptions(isBuild, pkg, options = {}) {
   return { buildAsarOption, buildEntryOption, buildVersionOption, postBuild };
 }
 
+// src/constant.ts
+var id = "electron-incremental-updater";
+var bytecodeId = `${id}-bytecode`;
+var loaderId = `${id}-loader`;
+
 // src/vite.ts
 function debugStartup(args) {
   process.env.VSCODE_DEBUG ? console.log("[startup] Electron App") : args.startup();
 }
-var id = "electron-incremental-updater";
-var log = (0, import_vite3.createLogger)("info", { prefix: `[${id}]` });
+function 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) {
-  const {
+  let {
     isBuild,
-    pkg,
+    pkg = resolvePackageJson(),
     main: _main,
     preload: _preload,
+    sourcemap,
+    minify,
     updater,
     useNotBundle = true,
     logParsedOptions
   } = options;
-  const _options = parseOptions(isBuild, pkg, updater);
+  if (!pkg) {
+    log.error(`package.json not found`, { timestamp: true });
+    return null;
+  }
+  const _options = parseOptions(pkg, sourcemap, minify, updater);
   try {
-    (0, import_node_fs4.rmSync)(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
-    (0, import_node_fs4.rmSync)(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
+    rmSync2(_options.buildAsarOption.electronDistPath, { recursive: true, force: true });
+    rmSync2(_options.buildEntryOption.entryOutputDirPath, { recursive: true, force: true });
   } catch (ignore) {
   }
   log.info(`remove old files`, { timestamp: true });
   const { buildAsarOption, buildEntryOption, buildVersionOption, postBuild } = _options;
   const { entryOutputDirPath, nativeModuleEntryMap, appEntryPath } = buildEntryOption;
-  const sourcemap = isBuild || !!process.env.VSCODE_DEBUG;
-  const _appPath = (0, import_node_path3.join)(entryOutputDirPath, "entry.js");
-  if ((0, import_node_path3.resolve)((0, import_vite3.normalizePath)(pkg.main)) !== (0, import_node_path3.resolve)((0, import_vite3.normalizePath)(_appPath))) {
-    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${(0, import_vite3.normalizePath)(_appPath)}"`);
+  sourcemap ??= isBuild || !!process.env.VSCODE_DEBUG;
+  const _appPath = normalizePath2(join2(entryOutputDirPath, "entry.js"));
+  if (resolve(normalizePath2(pkg.main)) !== resolve(_appPath)) {
+    throw new Error(`wrong "main" field in package.json: "${pkg.main}", it should be "${_appPath}"`);
   }
-  let isInit = false;
   const _buildEntry = async () => {
     await buildEntry(buildEntryOption);
-    log.info(`build entry to '${entryOutputDirPath}'`, { timestamp: true });
+    log.info(`vite build entry to '${entryOutputDirPath}'`, { timestamp: true });
   };
-  const _postBuild = postBuild ? async () => postBuild({
+  const _postBuild = postBuild ? async () => await postBuild({
     getPathFromEntryOutputDir(...paths) {
-      return (0, import_node_path3.join)(entryOutputDirPath, ...paths);
+      return join2(entryOutputDirPath, ...paths);
     },
-    existsAndCopyToEntryOutputDir({ from, to, skipIfExist = true }) {
-      if ((0, import_node_fs4.existsSync)(from)) {
-        const target = (0, import_node_path3.join)(entryOutputDirPath, to ?? (0, import_node_path3.basename)(from));
-        if (!skipIfExist || !(0, import_node_fs4.existsSync)(target)) {
+    copyToEntryOutputDir({ from, to, skipIfExist = true }) {
+      if (existsSync4(from)) {
+        const target = join2(entryOutputDirPath, to ?? basename2(from));
+        if (!skipIfExist || !existsSync4(target)) {
           try {
-            (0, import_node_fs4.cpSync)(from, target);
-          } catch (ignore) {
-            log.warn(`copy failed: ${ignore}`);
+            cpSync(from, target);
+          } catch (error) {
+            log.warn(`copy failed: ${error}`);
           }
         }
       }
     }
   }) : async () => {
   };
+  let isInit = false;
   const electronPluginOptions = {
     main: {
       entry: _main.files,
@@ -410,12 +396,12 @@ function electronWithUpdater(options) {
         }
         _main.onstart ? _main.onstart(args) : args.startup();
       },
-      vite: (0, import_vite3.mergeConfig)(
+      vite: mergeConfig(
         {
-          plugins: !isBuild && useNotBundle ? [(0, import_plugin.notBundle)()] : void 0,
+          plugins: [!isBuild && useNotBundle ? notBundle() : void 0],
           build: {
             sourcemap,
-            minify: isBuild,
+            minify,
             outDir: `${buildAsarOption.electronDistPath}/main`,
             rollupOptions: {
               external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
@@ -428,7 +414,7 @@ function electronWithUpdater(options) {
     preload: {
       input: _preload.files,
       onstart: _preload.onstart,
-      vite: (0, import_vite3.mergeConfig)(
+      vite: mergeConfig(
         {
           plugins: [
             {
@@ -439,6 +425,7 @@ function electronWithUpdater(options) {
               },
               async closeBundle() {
                 await _buildEntry();
+                await _postBuild();
                 await buildAsar(buildAsarOption);
                 log.info(`build asar to '${buildAsarOption.asarOutputPath}'`, { timestamp: true });
                 await buildVersion(buildVersionOption);
@@ -448,7 +435,7 @@ function electronWithUpdater(options) {
           ],
           build: {
             sourcemap: sourcemap ? "inline" : void 0,
-            minify: isBuild,
+            minify,
             outDir: `${buildAsarOption.electronDistPath}/preload`,
             rollupOptions: {
               external: Object.keys("dependencies" in pkg ? pkg.dependencies : {})
@@ -465,14 +452,14 @@ function electronWithUpdater(options) {
         ...electronPluginOptions,
         updater: { buildAsarOption, buildEntryOption, buildVersionOption }
       },
-      (key2, value) => key2 === "privateKey" || key2 === "cert" ? "***" : value,
+      (key, value) => key === "privateKey" || key === "cert" ? "***" : value,
       2
     ),
     { timestamp: true }
   );
   let extraHmrPlugin;
   if (nativeModuleEntryMap) {
-    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => (0, import_node_path3.resolve)((0, import_vite3.normalizePath)(file)));
+    const files = [...Object.values(nativeModuleEntryMap), appEntryPath].map((file) => resolve(normalizePath2(file)));
     extraHmrPlugin = {
       name: `${id}-dev`,
       apply() {
@@ -482,19 +469,18 @@ function electronWithUpdater(options) {
         server.watcher.add(files).on(
           "change",
           (p) => files.includes(p) && _buildEntry().then(async () => {
-            await import_vite_plugin_electron.startup.exit();
+            await startup.exit();
             await _postBuild();
-            await (0, import_vite_plugin_electron.startup)();
+            await startup();
           })
         );
       }
     };
   }
-  return [(0, import_simple.default)(electronPluginOptions), extraHmrPlugin];
+  return [ElectronSimple(electronPluginOptions), extraHmrPlugin];
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   debugStartup,
   electronWithUpdater,
   log
-});
+};

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "electron-incremental-update",
-  "version": "1.0.3",
+  "type": "module",
+  "version": "1.1.0",
   "description": "electron incremental update tools, powered by vite",
   "author": "subframe7536",
   "license": "MIT",
@@ -8,24 +9,24 @@
   "keywords": [
     "electron",
     "incremental update",
-    "updater"
+    "updater",
+    "bytecode"
   ],
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./vite": {
-      "import": "./dist/vite.mjs",
-      "require": "./dist/vite.js"
+      "import": "./dist/vite.js"
     },
     "./utils": {
-      "import": "./dist/utils.mjs",
-      "require": "./dist/utils.js"
+      "import": "./dist/utils.js",
+      "require": "./dist/utils.cjs"
     }
   },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "files": [
     "dist",
     "utils.d.ts",
@@ -35,7 +36,7 @@
   ],
   "scripts": {
     "dev": "tsup --watch",
-    "build": "tsup && node fix-module.js",
+    "build": "tsup && esno fix-module.cjs",
     "release": "pnpm test && pnpm run build && bumpp --all && npm publish",
     "test": "vitest --run",
     "lint": "eslint . --fix"
@@ -45,29 +46,25 @@
     "registry": "https://registry.npmjs.org/"
   },
   "peerDependencies": {
+    "@electron/asar": "*",
     "esbuild": "*",
     "vite-plugin-electron": "^0.15.6 || ^0.28"
   },
   "dependencies": {
-    "@electron/asar": "^3.2.9",
     "@subframe7536/type-utils": "^0.1.6",
     "selfsigned": "^2.4.1"
   },
   "devDependencies": {
-    "@subframe7536/eslint-config": "^0.6.0",
-    "@types/node": "^20.12.5",
-    "bumpp": "^9.4.0",
-    "electron": "28.1.1",
-    "eslint": "^8.57.0",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.4",
-    "vite": "^5.2.8",
-    "vite-plugin-electron": "^0.28.4",
-    "vitest": "^1.4.0"
-  },
-  "pnpm": {
-    "overrides": {
-      "has": "npm:@nolyfill/has@latest"
-    }
+    "@subframe7536/eslint-config": "^0.6.6",
+    "@types/node": "^20.14.7",
+    "bumpp": "^9.4.1",
+    "electron": "28.2.10",
+    "eslint": "^9.5.0",
+    "esno": "^4.7.0",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.2",
+    "vite": "^5.3.1",
+    "vite-plugin-electron": "^0.28.7",
+    "vitest": "^1.6.0"
   }
 }

package/utils.js

@@ -1 +1 @@
-module.exports = require('./dist/utils.js')
+module.exports = require('./dist/utils.cjs')

package/dist/chunk-GB6VLKJZ.mjs

@@ -1,95 +0,0 @@
-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) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/utils/zip.ts
-import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { gunzip, gzip } from "node:zlib";
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!existsSync(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
-  }
-  const compressedBuffer = readFileSync(gzipPath);
-  return new Promise((resolve, reject) => {
-    gunzip(compressedBuffer, (err, buffer) => {
-      rmSync(gzipPath);
-      if (err) {
-        reject(err);
-      }
-      writeFileSync(targetFilePath, buffer);
-      resolve(null);
-    });
-  });
-}
-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((resolve, reject) => {
-    gzip(buffer, (err, buffer2) => {
-      if (err) {
-        reject(err);
-      }
-      writeFileSync(targetFilePath, buffer2);
-      resolve(null);
-    });
-  });
-}
-
-// src/utils/noDep.ts
-function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
-  if (!originRepoURL.startsWith("https://github.com/")) {
-    throw new Error("origin url must start with https://github.com/");
-  }
-  originRepoURL = originRepoURL.trim().replace(/\/?$/, "/").trim();
-  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
-  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
-  return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
-}
-function handleUnexpectedErrors(callback) {
-  process.on("uncaughtException", callback);
-  process.on("unhandledRejection", callback);
-}
-function parseVersion(version) {
-  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
-  const match = semver.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;
-}
-function isUpdateJSON(json) {
-  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
-  return is(json) && is(json?.beta);
-}
-
-export {
-  __require,
-  unzipFile,
-  zipFile,
-  parseGithubCdnURL,
-  handleUnexpectedErrors,
-  parseVersion,
-  isUpdateJSON
-};