electron-incremental-update 1.2.0 → 2.0.0-beta.1

package/dist/utils.cjs

@@ -20,21 +20,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
+  decrypt: () => decrypt,
   disableHWAccForWin7: () => disableHWAccForWin7,
+  encrypt: () => encrypt,
+  getAppVersion: () => getAppVersion,
+  getEntryVersion: () => getEntryVersion,
   getPathFromAppNameAsar: () => getPathFromAppNameAsar,
-  getPaths: () => getPaths,
-  getVersions: () => getVersions,
+  getPathFromEntryAsar: () => getPathFromEntryAsar,
+  getPathFromPreload: () => getPathFromPreload,
+  getPathFromPublic: () => getPathFromPublic,
   handleUnexpectedErrors: () => handleUnexpectedErrors,
-  is: () => is,
+  hashString: () => hashString,
+  isDev: () => isDev,
+  isLinux: () => isLinux,
+  isLowerVersionDefault: () => isLowerVersionDefault,
+  isMac: () => isMac,
   isUpdateJSON: () => isUpdateJSON,
-  loadNativeModuleFromEntry: () => loadNativeModuleFromEntry,
-  parseGithubCdnURL: () => parseGithubCdnURL,
+  isWin: () => isWin,
+  loadPage: () => loadPage,
   parseVersion: () => parseVersion,
+  requireNative: () => requireNative,
   restartApp: () => restartApp,
   setAppUserModelId: () => setAppUserModelId,
   setPortableAppDataPath: () => setPortableAppDataPath,
+  signature: () => signature,
   singleInstance: () => singleInstance,
   unzipFile: () => unzipFile,
+  verifySignatureDefault: () => verifySignatureDefault,
   waitAppReady: () => waitAppReady,
   zipFile: () => zipFile
 });
@@ -43,46 +55,32 @@ module.exports = __toCommonJS(utils_exports);
 // src/utils/electron.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_node_os = require("os");
 var import_electron = require("electron");
-var is = {
-  dev: !import_electron.app.isPackaged,
-  win: process.platform === "win32",
-  mac: process.platform === "darwin",
-  linux: process.platform === "linux"
-};
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
 function getPathFromAppNameAsar(...path) {
-  return is.dev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
+  return isDev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
 }
-function getVersions() {
-  const platform = is.win ? "Windows" : is.mac ? "MacOS" : process.platform.toUpperCase();
-  return {
-    appVersion: is.dev ? import_electron.app.getVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8"),
-    entryVersion: import_electron.app.getVersion(),
-    electronVersion: process.versions.electron,
-    nodeVersion: process.versions.node,
-    systemVersion: `${platform} ${(0, import_node_os.release)()}`
-  };
+function getAppVersion() {
+  return isDev ? getEntryVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8");
 }
-function loadNativeModuleFromEntry(devEntryDirPath = "../../dist-entry", entryDirPath = (0, import_node_path.join)(import_electron.app.getAppPath(), (0, import_node_path.basename)(devEntryDirPath))) {
-  const path = is.dev ? devEntryDirPath : entryDirPath;
-  return (moduleName) => {
-    try {
-      return require((0, import_node_path.join)(path, moduleName));
-    } catch (error) {
-      console.error("fail to load module", error);
-    }
-  };
+function getEntryVersion() {
+  return import_electron.app.getVersion();
+}
+function requireNative(moduleName) {
+  return require((0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
 }
 function restartApp() {
   import_electron.app.relaunch();
   import_electron.app.quit();
 }
 function setAppUserModelId(id) {
-  import_electron.app.setAppUserModelId(is.dev ? process.execPath : id ?? `org.${import_electron.app.name}`);
+  isWin && import_electron.app.setAppUserModelId(id ?? `org.${import_electron.app.name}`);
 }
 function disableHWAccForWin7() {
-  if ((0, import_node_os.release)().startsWith("6.1")) {
+  if (require("os").release().startsWith("6.1")) {
     import_electron.app.disableHardwareAcceleration();
   }
 }
@@ -117,112 +115,65 @@ function waitAppReady(timeout = 1e3) {
     });
   });
 }
-function getPaths(entryDirName = "dist-entry") {
-  const root = (0, import_node_path.join)(__dirname, "..");
-  const mainDirPath = (0, import_node_path.join)(root, "main");
-  const preloadDirPath = (0, import_node_path.join)(root, "preload");
-  const rendererDirPath = (0, import_node_path.join)(root, "renderer");
-  const devServerURL = process.env.VITE_DEV_SERVER_URL;
-  const indexHTMLPath = (0, import_node_path.join)(rendererDirPath, "index.html");
-  const publicDirPath = devServerURL ? (0, import_node_path.join)(root, "../public") : rendererDirPath;
-  return {
-    /**
-     * @example
-     * ```ts
-     * devServerURL && win.loadURL(devServerURL)
-     * ```
-     */
-    devServerURL,
-    /**
-     * @example
-     * ```ts
-     * win.loadFile(indexHTMLPath)
-     * ```
-     */
-    indexHTMLPath,
-    /**
-     * get path inside entry asar
-     * @param paths joined path
-     */
-    getPathFromEntryAsar(...paths) {
-      return (0, import_node_path.join)(import_electron.app.getAppPath(), entryDirName, ...paths);
-    },
-    /**
-     * get path inside `${electron.app.name}.asar/main`
-     * @param paths joined path
-     */
-    getPathFromMain(...paths) {
-      return (0, import_node_path.join)(mainDirPath, ...paths);
-    },
-    /**
-     * get path inside `${electron.app.name}.asar/preload`
-     * @param paths joined path
-     */
-    getPathFromPreload(...paths) {
-      return (0, import_node_path.join)(preloadDirPath, ...paths);
-    },
-    /**
-     * get path inside public dir
-     * @param paths joined path
-     */
-    getPathFromPublic(...paths) {
-      return (0, import_node_path.join)(publicDirPath, ...paths);
-    }
-  };
+function loadPage(win, htmlFilePath = "index.html") {
+  isDev ? win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath) : win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+}
+function getPathFromPreload(...paths) {
+  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? (0, import_node_path.join)(import_electron.app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return (0, import_node_path.join)(import_electron.app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
 }
 
 // src/utils/zip.ts
 var import_node_fs2 = require("fs");
 var import_node_zlib = require("zlib");
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs2.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
   }
-  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
+  const buffer = (0, import_node_fs2.readFileSync)(filePath);
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliDecompress)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs2.rmSync)(gzipPath);
+    (0, import_node_zlib.brotliCompress)(buffer, (err, buffer2) => {
       if (err) {
         reject(err);
       }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
+      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer2);
       resolve(null);
     });
   });
 }
-async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
-  if (!(0, import_node_fs2.existsSync)(filePath)) {
-    throw new Error(`path to be zipped not exist: ${filePath}`);
+
+// src/utils/unzip.ts
+var import_node_fs3 = require("fs");
+var import_node_zlib2 = require("zlib");
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!(0, import_node_fs3.existsSync)(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
   }
-  const buffer = (0, import_node_fs2.readFileSync)(filePath);
+  const compressedBuffer = (0, import_node_fs3.readFileSync)(gzipPath);
   return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliCompress)(buffer, (err, buffer2) => {
+    (0, import_node_zlib2.brotliDecompress)(compressedBuffer, (err, buffer) => {
+      (0, import_node_fs3.rmSync)(gzipPath);
       if (err) {
         reject(err);
       }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer2);
+      (0, import_node_fs3.writeFileSync)(targetFilePath, buffer);
       resolve(null);
     });
   });
 }
 
-// src/utils/pure.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;
-}
+// src/utils/version.ts
 function handleUnexpectedErrors(callback) {
   process.on("uncaughtException", callback);
   process.on("unhandledRejection", callback);
 }
 function parseVersion(version) {
-  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i;
-  const match = semver.exec(version);
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([a-z0-9.-]+))?/i.exec(version);
   if (!match) {
     throw new TypeError(`invalid version: ${version}`);
   }
@@ -244,27 +195,99 @@ function parseVersion(version) {
   }
   return ret;
 }
+function isLowerVersionDefault(oldVer, newVer) {
+  const oldV = parseVersion(oldVer);
+  const newV = parseVersion(newVer);
+  function compareStrings(str1, str2) {
+    if (str1 === "") {
+      return str2 !== "";
+    } else if (str2 === "") {
+      return true;
+    }
+    return str1 < str2;
+  }
+  for (let key of Object.keys(oldV)) {
+    if (key === "stage" && compareStrings(oldV[key], newV[key])) {
+      return true;
+    } else if (oldV[key] !== newV[key]) {
+      return oldV[key] < newV[key];
+    }
+  }
+  return false;
+}
 function isUpdateJSON(json) {
-  const is2 = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
-  return is2(json) && is2(json?.beta);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is(json) && is(json?.beta);
+}
+
+// src/utils/crypto/decrypt.ts
+var import_node_crypto2 = require("crypto");
+
+// src/utils/crypto/utils.ts
+var import_node_crypto = require("crypto");
+function hashString(data, length) {
+  const hash = (0, import_node_crypto.createHash)("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+
+// src/utils/crypto/decrypt.ts
+function decrypt(encryptedText, key, iv) {
+  const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function verifySignatureDefault(buffer, signature2, cert) {
+  try {
+    const [sig, version] = decrypt(signature2, hashString(cert, 32), hashString(buffer, 16)).split("%");
+    const result = (0, import_node_crypto2.createVerify)("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : void 0;
+  } catch (error) {
+    return void 0;
+  }
+}
+
+// src/utils/crypto/encrypt.ts
+var import_node_crypto3 = require("crypto");
+function encrypt(plainText, key, iv) {
+  const cipher = (0, import_node_crypto3.createCipheriv)("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", "base64url");
+  encrypted += cipher.final("base64url");
+  return encrypted;
+}
+function signature(buffer, privateKey, cert, version) {
+  const sig = (0, import_node_crypto3.createSign)("RSA-SHA256").update(buffer).sign((0, import_node_crypto3.createPrivateKey)(privateKey), "base64");
+  return encrypt(`${sig}%${version}`, hashString(cert, 32), hashString(buffer, 16));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  decrypt,
   disableHWAccForWin7,
+  encrypt,
+  getAppVersion,
+  getEntryVersion,
   getPathFromAppNameAsar,
-  getPaths,
-  getVersions,
+  getPathFromEntryAsar,
+  getPathFromPreload,
+  getPathFromPublic,
   handleUnexpectedErrors,
-  is,
+  hashString,
+  isDev,
+  isLinux,
+  isLowerVersionDefault,
+  isMac,
   isUpdateJSON,
-  loadNativeModuleFromEntry,
-  parseGithubCdnURL,
+  isWin,
+  loadPage,
   parseVersion,
+  requireNative,
   restartApp,
   setAppUserModelId,
   setPortableAppDataPath,
+  signature,
   singleInstance,
   unzipFile,
+  verifySignatureDefault,
   waitAppReady,
   zipFile
 });

package/dist/utils.d.cts

@@ -1,60 +1,40 @@
 import { BrowserWindow } from 'electron';
-export { U as UpdateInfo, a as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseGithubCdnURL, b as parseVersion } from './pure-GoN_3MEj.cjs';
+export { a as UpdateInfo, U as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isLowerVersionDefault, b as isUpdateJSON, p as parseVersion } from './version-CffZWDhZ.cjs';
+export { d as decrypt, v as verifySignatureDefault } from './decrypt-BNBcodiO.cjs';
 
 /**
- * app info
+ * compile time dev check
  */
-declare const is: {
-    readonly dev: boolean;
-    readonly win: boolean;
-    readonly mac: boolean;
-    readonly linux: boolean;
-};
+declare const isDev: boolean;
+declare const isWin: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
 /**
  * get the absolute path of `${electron.app.name}.asar` (not `app.asar`)
  *
- * if is in dev, return `'DEV.asar'`
+ * if is in dev, **always** return `'DEV.asar'`
  */
 declare function getPathFromAppNameAsar(...path: string[]): string;
 /**
- * get versions of App, Entry, Electron, Node and System
- *
- * App version is read from `version` file in `${electron.app.name}.asar`
- *
- * Entry version is read from `package.json`
- *
- * SystemVersion: `${platform} ${os.release()}`
+ * get app version, if is in dev, return `getEntryVersion()`
  */
-declare function getVersions(): {
-    appVersion: string;
-    entryVersion: string;
-    electronVersion: string;
-    nodeVersion: string;
-    systemVersion: string;
-};
+declare function getAppVersion(): string;
 /**
- * load native module from entry
- * @param moduleName file name in entry
+ * get entry version
  */
-type RequireNative = <T = any>(moduleName: string) => T;
+declare function getEntryVersion(): string;
 /**
- * load module from entry, **only for main and preload**
- * @remark use `require`, only support **CommonJS**
- * @param devEntryDirPath entry directory path when dev, default `../../dist-entry`
- * @param entryDirPath entry directory path when not dev, default `join(app.getAppPath(), basename(devEntryDirPath))`
- * @example
- * const requireNative = loadNativeModuleFromEntry()
- * const db = requireNative<typeof import('../native/db')>('db')
- * db.test()
+ * use `require` to load native module from entry
+ * @param moduleName file name in entry
  */
-declare function loadNativeModuleFromEntry(devEntryDirPath?: string, entryDirPath?: string): RequireNative;
+declare function requireNative<T = any>(moduleName: string): T;
 /**
  * Restarts the Electron app.
  */
 declare function restartApp(): void;
 /**
  * fix app use model id, only for Windows
- * @param id app id @default `org.${electron.app.name}`
+ * @param id app id, default is `org.${electron.app.name}`
  */
 declare function setAppUserModelId(id?: string): void;
 /**
@@ -80,47 +60,22 @@ declare function setPortableAppDataPath(dirName?: string): void;
  */
 declare function waitAppReady(timeout?: number): Promise<void>;
 /**
- * get paths, **only for main and preload**
- * @param entryDirName entry dir name, default to `dist-entry`
+ * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
+ * @param win window
+ * @param htmlFilePath html file path, default is `index.html`
  */
-declare function getPaths(entryDirName?: string): {
-    /**
-     * @example
-     * ```ts
-     * devServerURL && win.loadURL(devServerURL)
-     * ```
-     */
-    devServerURL: string | undefined;
-    /**
-     * @example
-     * ```ts
-     * win.loadFile(indexHTMLPath)
-     * ```
-     */
-    indexHTMLPath: string;
-    /**
-     * get path inside entry asar
-     * @param paths joined path
-     */
-    getPathFromEntryAsar(...paths: string[]): string;
-    /**
-     * get path inside `${electron.app.name}.asar/main`
-     * @param paths joined path
-     */
-    getPathFromMain(...paths: string[]): string;
-    /**
-     * get path inside `${electron.app.name}.asar/preload`
-     * @param paths joined path
-     */
-    getPathFromPreload(...paths: string[]): string;
-    /**
-     * get path inside public dir
-     * @param paths joined path
-     */
-    getPathFromPublic(...paths: string[]): string;
-};
+declare function loadPage(win: BrowserWindow, htmlFilePath?: string): void;
+declare function getPathFromPreload(...paths: string[]): string;
+declare function getPathFromPublic(...paths: string[]): string;
+declare function getPathFromEntryAsar(...paths: string[]): string;
 
-declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<unknown>;
 declare function zipFile(filePath: string, targetFilePath?: string): Promise<unknown>;
 
-export { disableHWAccForWin7, getPathFromAppNameAsar, getPaths, getVersions, is, loadNativeModuleFromEntry, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance, unzipFile, waitAppReady, zipFile };
+declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<unknown>;
+
+declare function encrypt(plainText: string, key: Buffer, iv: Buffer): string;
+declare function signature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
+
+declare function hashString(data: string | Buffer, length: number): Buffer;
+
+export { disableHWAccForWin7, encrypt, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, hashString, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, signature, singleInstance, unzipFile, waitAppReady, zipFile };

package/dist/utils.d.ts

@@ -1,60 +1,40 @@
 import { BrowserWindow } from 'electron';
-export { U as UpdateInfo, a as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isUpdateJSON, p as parseGithubCdnURL, b as parseVersion } from './pure-GoN_3MEj.js';
+export { a as UpdateInfo, U as UpdateJSON, V as Version, h as handleUnexpectedErrors, i as isLowerVersionDefault, b as isUpdateJSON, p as parseVersion } from './version-CffZWDhZ.js';
+export { d as decrypt, v as verifySignatureDefault } from './decrypt-BNBcodiO.js';
 
 /**
- * app info
+ * compile time dev check
  */
-declare const is: {
-    readonly dev: boolean;
-    readonly win: boolean;
-    readonly mac: boolean;
-    readonly linux: boolean;
-};
+declare const isDev: boolean;
+declare const isWin: boolean;
+declare const isMac: boolean;
+declare const isLinux: boolean;
 /**
  * get the absolute path of `${electron.app.name}.asar` (not `app.asar`)
  *
- * if is in dev, return `'DEV.asar'`
+ * if is in dev, **always** return `'DEV.asar'`
  */
 declare function getPathFromAppNameAsar(...path: string[]): string;
 /**
- * get versions of App, Entry, Electron, Node and System
- *
- * App version is read from `version` file in `${electron.app.name}.asar`
- *
- * Entry version is read from `package.json`
- *
- * SystemVersion: `${platform} ${os.release()}`
+ * get app version, if is in dev, return `getEntryVersion()`
  */
-declare function getVersions(): {
-    appVersion: string;
-    entryVersion: string;
-    electronVersion: string;
-    nodeVersion: string;
-    systemVersion: string;
-};
+declare function getAppVersion(): string;
 /**
- * load native module from entry
- * @param moduleName file name in entry
+ * get entry version
  */
-type RequireNative = <T = any>(moduleName: string) => T;
+declare function getEntryVersion(): string;
 /**
- * load module from entry, **only for main and preload**
- * @remark use `require`, only support **CommonJS**
- * @param devEntryDirPath entry directory path when dev, default `../../dist-entry`
- * @param entryDirPath entry directory path when not dev, default `join(app.getAppPath(), basename(devEntryDirPath))`
- * @example
- * const requireNative = loadNativeModuleFromEntry()
- * const db = requireNative<typeof import('../native/db')>('db')
- * db.test()
+ * use `require` to load native module from entry
+ * @param moduleName file name in entry
  */
-declare function loadNativeModuleFromEntry(devEntryDirPath?: string, entryDirPath?: string): RequireNative;
+declare function requireNative<T = any>(moduleName: string): T;
 /**
  * Restarts the Electron app.
  */
 declare function restartApp(): void;
 /**
  * fix app use model id, only for Windows
- * @param id app id @default `org.${electron.app.name}`
+ * @param id app id, default is `org.${electron.app.name}`
  */
 declare function setAppUserModelId(id?: string): void;
 /**
@@ -80,47 +60,22 @@ declare function setPortableAppDataPath(dirName?: string): void;
  */
 declare function waitAppReady(timeout?: number): Promise<void>;
 /**
- * get paths, **only for main and preload**
- * @param entryDirName entry dir name, default to `dist-entry`
+ * load `process.env.VITE_DEV_SERVER_URL` when dev, else load html file
+ * @param win window
+ * @param htmlFilePath html file path, default is `index.html`
  */
-declare function getPaths(entryDirName?: string): {
-    /**
-     * @example
-     * ```ts
-     * devServerURL && win.loadURL(devServerURL)
-     * ```
-     */
-    devServerURL: string | undefined;
-    /**
-     * @example
-     * ```ts
-     * win.loadFile(indexHTMLPath)
-     * ```
-     */
-    indexHTMLPath: string;
-    /**
-     * get path inside entry asar
-     * @param paths joined path
-     */
-    getPathFromEntryAsar(...paths: string[]): string;
-    /**
-     * get path inside `${electron.app.name}.asar/main`
-     * @param paths joined path
-     */
-    getPathFromMain(...paths: string[]): string;
-    /**
-     * get path inside `${electron.app.name}.asar/preload`
-     * @param paths joined path
-     */
-    getPathFromPreload(...paths: string[]): string;
-    /**
-     * get path inside public dir
-     * @param paths joined path
-     */
-    getPathFromPublic(...paths: string[]): string;
-};
+declare function loadPage(win: BrowserWindow, htmlFilePath?: string): void;
+declare function getPathFromPreload(...paths: string[]): string;
+declare function getPathFromPublic(...paths: string[]): string;
+declare function getPathFromEntryAsar(...paths: string[]): string;
 
-declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<unknown>;
 declare function zipFile(filePath: string, targetFilePath?: string): Promise<unknown>;
 
-export { disableHWAccForWin7, getPathFromAppNameAsar, getPaths, getVersions, is, loadNativeModuleFromEntry, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance, unzipFile, waitAppReady, zipFile };
+declare function unzipFile(gzipPath: string, targetFilePath?: string): Promise<unknown>;
+
+declare function encrypt(plainText: string, key: Buffer, iv: Buffer): string;
+declare function signature(buffer: Buffer, privateKey: string, cert: string, version: string): string;
+
+declare function hashString(data: string | Buffer, length: number): Buffer;
+
+export { disableHWAccForWin7, encrypt, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, hashString, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, signature, singleInstance, unzipFile, waitAppReady, zipFile };