electron-incremental-update 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/chunk-5WFXC5GU.js

@@ -0,0 +1,43 @@
+import { writeFileSync } from 'node:fs';
+import { brotliDecompress } from 'node:zlib';
+import { createHash, createCipheriv, createSign, createPrivateKey, createDecipheriv, createVerify } from 'node:crypto';
+
+// src/utils/unzip.ts
+async function defaultUnzipFile(buffer, targetFilePath) {
+  return new Promise((resolve, reject) => {
+    brotliDecompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer2);
+      resolve();
+    });
+  });
+}
+function hashBuffer(data, length) {
+  const hash = createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesEncrypt(plainText, key, iv) {
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  return cipher.update(plainText, "utf8", "base64url") + cipher.final("base64url");
+}
+function defaultSignature(buffer, privateKey, cert, version) {
+  const sig = createSign("RSA-SHA256").update(buffer).sign(createPrivateKey(privateKey), "base64");
+  return aesEncrypt(`${sig}%${version}`, hashBuffer(cert, 32), hashBuffer(buffer, 16));
+}
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerify(buffer, signature, cert) {
+  try {
+    const [sig, version] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    const result = createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+    return result ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export { aesDecrypt, aesEncrypt, defaultSignature, defaultUnzipFile, defaultVerify, hashBuffer };

package/dist/chunk-BVFQWBLK.js

@@ -0,0 +1,76 @@
+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/version.ts
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+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;
+}
+function defaultIsLowerVersion(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 is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  return is(json) && is(json?.beta);
+}
+function defaultVersionJsonGenerator(existingJson, buffer, signature, version, minimumVersion) {
+  existingJson.beta = {
+    version,
+    minimumVersion,
+    signature,
+    size: buffer.length
+  };
+  if (!parseVersion(version).stage) {
+    existingJson.version = version;
+    existingJson.minimumVersion = minimumVersion;
+    existingJson.signature = signature;
+    existingJson.size = buffer.length;
+  }
+  return existingJson;
+}
+
+export { __require, defaultIsLowerVersion, defaultVersionJsonGenerator, handleUnexpectedErrors, isUpdateJSON, parseVersion };

package/dist/chunk-PNYRQYFC.js

@@ -0,0 +1,77 @@
+import { __require } from './chunk-BVFQWBLK.js';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { app } from 'electron';
+
+var isDev = __EIU_IS_DEV__;
+var isWin = process.platform === "win32";
+var isMac = process.platform === "darwin";
+var isLinux = process.platform === "linux";
+function getPathFromAppNameAsar(...path) {
+  return isDev ? "DEV.asar" : join(dirname(app.getAppPath()), `${app.name}.asar`, ...path);
+}
+function getAppVersion() {
+  return isDev ? getEntryVersion() : readFileSync(getPathFromAppNameAsar("version"), "utf-8");
+}
+function getEntryVersion() {
+  return app.getVersion();
+}
+function requireNative(moduleName) {
+  return __require(join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, moduleName));
+}
+function restartApp() {
+  app.relaunch();
+  app.quit();
+}
+function setAppUserModelId(id) {
+  if (isWin) {
+    app.setAppUserModelId(id ?? `org.${app.name}`);
+  }
+}
+function disableHWAccForWin7() {
+  if (__require("node:os").release().startsWith("6.1")) {
+    app.disableHardwareAcceleration();
+  }
+}
+function singleInstance(window) {
+  const result = app.requestSingleInstanceLock();
+  if (result) {
+    app.on("second-instance", () => {
+      if (window) {
+        window.show();
+        if (window.isMinimized()) {
+          window.restore();
+        }
+        window.focus();
+      }
+    });
+  } else {
+    app.quit();
+  }
+  return result;
+}
+function setPortableAppDataPath(dirName = "data") {
+  const portablePath = join(dirname(app.getPath("exe")), dirName);
+  if (!existsSync(portablePath)) {
+    mkdirSync(portablePath);
+  }
+  app.setPath("appData", portablePath);
+}
+function loadPage(win, htmlFilePath = "index.html") {
+  if (isDev) {
+    win.loadURL(process.env.VITE_DEV_SERVER_URL + htmlFilePath);
+  } else {
+    win.loadFile(getPathFromAppNameAsar("renderer", htmlFilePath));
+  }
+}
+function getPathFromPreload(...paths) {
+  return isDev ? join(app.getAppPath(), __EIU_ELECTRON_DIST_PATH__, "preload", ...paths) : getPathFromAppNameAsar("preload", ...paths);
+}
+function getPathFromPublic(...paths) {
+  return isDev ? join(app.getAppPath(), "public", ...paths) : getPathFromAppNameAsar("renderer", ...paths);
+}
+function getPathFromEntryAsar(...paths) {
+  return join(app.getAppPath(), __EIU_ENTRY_DIST_PATH__, ...paths);
+}
+
+export { disableHWAccForWin7, getAppVersion, getEntryVersion, getPathFromAppNameAsar, getPathFromEntryAsar, getPathFromPreload, getPathFromPublic, isDev, isLinux, isMac, isWin, loadPage, requireNative, restartApp, setAppUserModelId, setPortableAppDataPath, singleInstance };

package/dist/index.cjs

@@ -1,94 +1,46 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/entry.ts
-var entry_exports = {};
-__export(entry_exports, {
-  ErrorInfo: () => ErrorInfo,
-  Updater: () => Updater,
-  UpdaterError: () => UpdaterError,
-  initApp: () => initApp,
-  startupWithUpdater: () => startupWithUpdater
-});
-module.exports = __toCommonJS(entry_exports);
-var import_node_path2 = require("path");
-var import_node_fs5 = require("fs");
-var import_electron4 = require("electron");
+var path = require('path');
+var fs = require('fs');
+var electron = require('electron');
+var events = require('events');
 
-// src/updater/core.ts
-var import_node_fs3 = require("fs");
-var import_node_stream = require("stream");
-var import_electron2 = require("electron");
+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/version.ts
 function isUpdateJSON(json) {
   const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
   return is(json) && is(json?.beta);
 }
-
-// src/utils/electron.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_electron = require("electron");
 var isDev = __EIU_IS_DEV__;
-var isWin = process.platform === "win32";
-var isMac = process.platform === "darwin";
-var isLinux = process.platform === "linux";
-function getPathFromAppNameAsar(...path) {
-  return isDev ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${import_electron.app.name}.asar`, ...path);
+process.platform === "win32";
+process.platform === "darwin";
+process.platform === "linux";
+function getPathFromAppNameAsar(...path$1) {
+  return isDev ? "DEV.asar" : path.join(path.dirname(electron.app.getAppPath()), `${electron.app.name}.asar`, ...path$1);
 }
 function getAppVersion() {
-  return isDev ? getEntryVersion() : (0, import_node_fs.readFileSync)(getPathFromAppNameAsar("version"), "utf-8");
+  return isDev ? getEntryVersion() : fs.readFileSync(getPathFromAppNameAsar("version"), "utf-8");
 }
 function getEntryVersion() {
-  return import_electron.app.getVersion();
+  return electron.app.getVersion();
 }
 function restartApp() {
-  import_electron.app.relaunch();
-  import_electron.app.quit();
-}
-
-// src/utils/unzip.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}`);
-  }
-  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
-  return new Promise((resolve, reject) => {
-    (0, import_node_zlib.brotliDecompress)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs2.rmSync)(gzipPath);
-      if (err) {
-        reject(err);
-      }
-      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
-      resolve();
-    });
-  });
+  electron.app.relaunch();
+  electron.app.quit();
 }
 
 // src/updater/types.ts
 var ErrorInfo = {
   download: "Download failed",
   validate: "Validate failed",
-  param: "Missing params"
+  param: "Missing params",
+  network: "Network error"
 };
 var UpdaterError = class extends Error {
   code;
@@ -99,12 +51,10 @@ var UpdaterError = class extends Error {
 };
 
 // src/updater/core.ts
-var Updater = class extends import_node_stream.EventEmitter {
+var Updater = class extends events.EventEmitter {
   CERT = __EIU_SIGNATURE_CERT__;
   info;
-  options;
   asarPath;
-  gzipPath;
   tmpFilePath;
   provider;
   /**
@@ -112,22 +62,13 @@ var Updater = class extends import_node_stream.EventEmitter {
    */
   logger;
   /**
-   * URL handler hook
-   *
-   * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDNs}
-   * @param url source url
-   * @param isDownloadAsar whether is download asar
+   * whether to receive beta update
    */
-  handleURL;
+  receiveBeta;
   /**
-   * whether receive beta version
+   * whether force update in DEV
    */
-  get receiveBeta() {
-    return !!this.options.receiveBeta;
-  }
-  set receiveBeta(receiveBeta) {
-    this.options.receiveBeta = receiveBeta;
-  }
+  forceUpdate;
   /**
    * initialize incremental updater
    * @param provider update provider
@@ -136,7 +77,7 @@ var Updater = class extends import_node_stream.EventEmitter {
   constructor(provider, option = {}) {
     super();
     this.provider = provider;
-    this.options = option;
+    this.receiveBeta = option.receiveBeta;
     if (option.SIGNATURE_CERT) {
       this.CERT = option.SIGNATURE_CERT;
     }
@@ -153,17 +94,12 @@ var Updater = class extends import_node_stream.EventEmitter {
       this.logger.info("no logger set, enable dev-only logger");
     }
     this.asarPath = getPathFromAppNameAsar();
-    this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async fetch(format, data) {
-    if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
+    if (fs.existsSync(this.tmpFilePath)) {
       this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
-      (0, import_node_fs3.rmSync)(this.tmpFilePath);
-    }
-    if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
-      this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
-      (0, import_node_fs3.rmSync)(this.gzipPath);
+      fs.rmSync(this.tmpFilePath);
     }
     if (typeof data === "object") {
       if (format === "json" && isUpdateJSON(data) || format === "buffer" && Buffer.isBuffer(data)) {
@@ -175,11 +111,11 @@ var Updater = class extends import_node_stream.EventEmitter {
     }
     this.logger?.debug(`download from ${this.provider.name}`);
     try {
-      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadAsar(import_electron2.app.name, this.info, (data2) => this.emit("download-progress", data2));
+      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadAsar(electron.app.name, this.info, (data2) => this.emit("download-progress", data2));
       this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${result.length}` : ""}`);
       return result;
     } catch (e) {
-      this.err(`download ${format} failed`, "download", `download ${format} failed: ${e}`);
+      this.err(`fetch ${format} failed`, "network", `download ${format} failed: ${e}`);
     }
   }
   /**
@@ -194,11 +130,11 @@ var Updater = class extends import_node_stream.EventEmitter {
     const emitUnavailable = (msg) => {
       this.logger?.info(msg);
       this.emit("update-unavailable", msg);
+      return false;
     };
     const _data = await this.fetch("json", data);
     if (!_data) {
-      emitUnavailable("failed to get update info");
-      return false;
+      return emitUnavailable("failed to get update info");
     }
     let { signature, size, version, minimumVersion, beta } = _data;
     if (this.receiveBeta) {
@@ -208,21 +144,18 @@ var Updater = class extends import_node_stream.EventEmitter {
       size = beta.size;
     }
     this.logger?.debug(`checked update, version: ${version}, size: ${size}, signature: ${signature}`);
-    if (isDev) {
-      emitUnavailable("in dev mode, skip check update");
-      return false;
+    if (isDev && !this.forceUpdate && !data) {
+      return emitUnavailable("skip check update in dev mode, to force update, set `updater.forceUpdate` to true or call checkUpdate with UpdateJSON");
     }
     const isLowerVersion = this.provider.isLowerVersion;
     const entryVersion = getEntryVersion();
     const appVersion = getAppVersion();
     if (isLowerVersion(entryVersion, minimumVersion)) {
-      emitUnavailable(`entry version (${entryVersion}) < minimumVersion (${minimumVersion})`);
-      return false;
+      return emitUnavailable(`entry version (${entryVersion}) < minimumVersion (${minimumVersion})`);
     }
     this.logger?.info(`check update: current version is ${appVersion}, new version is ${version}`);
     if (!isLowerVersion(appVersion, version)) {
-      emitUnavailable(`current version (${appVersion}) < new version (${version})`);
-      return false;
+      return emitUnavailable(`current version (${appVersion}) < new version (${version})`);
     }
     this.logger?.info(`update available: ${version}`);
     this.info = { signature, minimumVersion, version, size };
@@ -230,11 +163,11 @@ var Updater = class extends import_node_stream.EventEmitter {
     return true;
   }
   async download(data, sig) {
-    if (!this.info) {
-      this.err("download failed", "param", "no update info, call `checkUpdate` first");
+    const _sig = sig ?? this.info?.signature;
+    if (!_sig) {
+      this.err("download failed", "param", "no update signature, please call `checkUpdate` first");
       return false;
     }
-    const _sig = sig ?? this.info.signature;
     const buffer = await this.fetch("buffer", data ? Buffer.from(data) : void 0);
     if (!buffer) {
       this.err("download failed", "param", "no update asar file buffer");
@@ -243,21 +176,19 @@ var Updater = class extends import_node_stream.EventEmitter {
     this.logger?.debug("verify start");
     const _ver = await this.provider.verifySignaure(buffer, _sig, this.CERT);
     if (!_ver) {
-      this.err("verify failed", "validate", "invalid signature / certificate pair");
+      this.err("download failed", "validate", "invalid signature / certificate pair");
       return false;
     }
     this.logger?.debug("verify success");
     try {
-      this.logger?.debug(`write to ${this.gzipPath}`);
-      (0, import_node_fs3.writeFileSync)(this.gzipPath, buffer);
       this.logger?.debug(`extract to ${this.tmpFilePath}`);
-      await unzipFile(this.gzipPath, this.tmpFilePath);
+      await this.provider.unzipFile(buffer, this.tmpFilePath);
       this.logger?.info(`download success, version: ${_ver}`);
       this.info = void 0;
       this.emit("update-downloaded");
       return true;
     } catch (error) {
-      this.err("unwrap asar failed", "download", `fail to unwrap asar file, ${error}`);
+      this.err("download failed", "download", `fail to unwrap asar file, ${error}`);
       return false;
     }
   }
@@ -268,28 +199,28 @@ var Updater = class extends import_node_stream.EventEmitter {
     this.logger?.info("quit and install");
     restartApp();
   }
+  /**
+   * setup provider URL handler
+   *
+   * @example
+   * updater.setURLHandler((url, isDownloadingAsar) => {
+   *   if (isDownloadingAsar) {
+   *     return url.replace('https://raw.githubusercontent.com', 'https://cdn.jsdelivr.net/gh')
+   *   }
+   * })
+   */
+  setURLHandler(handler) {
+    this.provider.urlHandler = handler;
+  }
 };
 
-// src/utils/zip.ts
-var import_node_fs4 = require("fs");
-var import_node_zlib2 = require("zlib");
-
-// src/utils/crypto/decrypt.ts
-var import_node_crypto2 = require("crypto");
-
-// src/utils/crypto/utils.ts
-var import_node_crypto = require("crypto");
-
-// src/utils/crypto/encrypt.ts
-var import_node_crypto3 = require("crypto");
-
 // src/entry.ts
 function startupWithUpdater(fn) {
   return fn;
 }
 var defaultOnInstall = (install, _, __, logger) => {
   install();
-  logger.info(`update success!`);
+  logger?.info(`update success!`);
 };
 async function initApp(appOptions) {
   const {
@@ -305,32 +236,38 @@ async function initApp(appOptions) {
   } else {
     updaterInstance = await updater();
   }
-  const logger = updaterInstance.logger || console;
+  let logger = updaterInstance.logger;
+  if (isDev && !logger) {
+    logger = {
+      info: (...args) => console.log("[EIU-INFO ]", ...args),
+      debug: (...args) => console.log("[EIU-DEBUG]", ...args),
+      warn: (...args) => console.log("[EIU-WARN ]", ...args),
+      error: (...args) => console.error("[EIU-ERROR]", ...args)
+    };
+  }
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
-    if ((0, import_node_fs5.existsSync)(tempAsarPath)) {
-      logger.info(`installing new asar: ${tempAsarPath}`);
-      await onInstall(() => (0, import_node_fs5.renameSync)(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
+    if (fs.existsSync(tempAsarPath)) {
+      logger?.info(`installing new asar: ${tempAsarPath}`);
+      await onInstall(() => fs.renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainFilePath = (0, import_node_path2.join)(
-      isDev ? (0, import_node_path2.join)(import_electron4.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+    const mainFilePath = path.join(
+      isDev ? path.join(electron.app.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
       "main",
       __EIU_MAIN_FILE__
     );
     await beforeStart?.(mainFilePath, logger);
-    require(mainFilePath)(updaterInstance);
+    __require(mainFilePath)(updaterInstance);
   } catch (error) {
-    logger.error("startup error", error);
+    logger?.error("startup error", error);
     onStartError?.(error, logger);
-    import_electron4.app.quit();
+    electron.app.quit();
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ErrorInfo,
-  Updater,
-  UpdaterError,
-  initApp,
-  startupWithUpdater
-});
+
+exports.ErrorInfo = ErrorInfo;
+exports.Updater = Updater;
+exports.UpdaterError = UpdaterError;
+exports.initApp = initApp;
+exports.startupWithUpdater = startupWithUpdater;

package/dist/index.d.cts

@@ -1,12 +1,13 @@
-import { EventEmitter } from 'node:stream';
-import { U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.cjs';
-import { D as DownloadingInfo, U as URLHandler, I as IProvider } from './types-COqp44eg.cjs';
+import { EventEmitter } from 'node:events';
+import { U as UpdateJSON, a as UpdateInfo } from './version-CemSHimT.cjs';
+import { D as DownloadingInfo, I as IProvider, U as URLHandler } from './types-Tequ_V2o.cjs';
 import '@subframe7536/type-utils';
 
 declare const ErrorInfo: {
     readonly download: "Download failed";
     readonly validate: "Validate failed";
     readonly param: "Missing params";
+    readonly network: "Network error";
 };
 declare class UpdaterError extends Error {
     code: keyof typeof ErrorInfo;
@@ -60,9 +61,7 @@ declare class Updater extends EventEmitter<{
 }> {
     private CERT;
     private info?;
-    private options;
     private asarPath;
-    private gzipPath;
     private tmpFilePath;
     private provider;
     /**
@@ -70,18 +69,13 @@ declare class Updater extends EventEmitter<{
      */
     logger?: Logger;
     /**
-     * URL handler hook
-     *
-     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDNs}
-     * @param url source url
-     * @param isDownloadAsar whether is download asar
+     * whether to receive beta update
      */
-    handleURL?: URLHandler;
+    receiveBeta?: boolean;
     /**
-     * whether receive beta version
+     * whether force update in DEV
      */
-    get receiveBeta(): boolean;
-    set receiveBeta(receiveBeta: boolean);
+    forceUpdate?: boolean;
     /**
      * initialize incremental updater
      * @param provider update provider
@@ -122,11 +116,22 @@ declare class Updater extends EventEmitter<{
      * @param data existing `asar.gz` buffer
      * @param sig signature
      */
-    download(data: Uint8Array, sig: string): Promise<boolean>;
+    download(data: Uint8Array | Buffer, sig: string): Promise<boolean>;
     /**
      * quit App and install
      */
     quitAndInstall(): void;
+    /**
+     * setup provider URL handler
+     *
+     * @example
+     * updater.setURLHandler((url, isDownloadingAsar) => {
+     *   if (isDownloadingAsar) {
+     *     return url.replace('https://raw.githubusercontent.com', 'https://cdn.jsdelivr.net/gh')
+     *   }
+     * })
+     */
+    setURLHandler(handler: URLHandler): void;
 }
 
 type Promisable<T> = T | Promise<T>;
@@ -138,7 +143,7 @@ type Promisable<T> = T | Promise<T>;
  * @param logger logger
  * @default install(); logger.info(`update success!`)
  */
-type OnInstallFunction = (install: VoidFunction, tempAsarPath: string, appNameAsarPath: string, logger: Logger) => Promisable<void>;
+type OnInstallFunction = (install: VoidFunction, tempAsarPath: string, appNameAsarPath: string, logger?: Logger) => Promisable<void>;
 interface AppOption {
     /**
      * update provider
@@ -157,13 +162,13 @@ interface AppOption {
      * @param mainFilePath main file path of `${app.name}.asar`
      * @param logger logger
      */
-    beforeStart?: (mainFilePath: string, logger: Logger) => Promisable<void>;
+    beforeStart?: (mainFilePath: string, logger?: Logger) => Promisable<void>;
     /**
      * hooks on app start up error
      * @param err installing or startup error
      * @param logger logger
      */
-    onStartError?: (err: unknown, logger: Logger) => void;
+    onStartError?: (err: unknown, logger?: Logger) => void;
 }
 /**
  * utils for startuping with updater