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

package/dist/index.js

@@ -1,17 +1,16 @@
 import {
   __require,
+  getAppVersion,
+  getEntryVersion,
   getPathFromAppNameAsar,
-  getVersions,
-  is,
+  isDev,
   isUpdateJSON,
-  parseVersion,
   restartApp,
-  unzipFile,
-  waitAppReady
-} from "./chunk-SBPTSLG7.js";
+  unzipFile
+} from "./chunk-RSLOPAIZ.js";
 
-// src/index.ts
-import { resolve } from "node:path";
+// src/entry.ts
+import { join } from "node:path";
 import { existsSync as existsSync2, renameSync } from "node:fs";
 import { app as app2 } from "electron";
 
@@ -19,36 +18,9 @@ import { app as app2 } from "electron";
 import { existsSync, rmSync, writeFileSync } from "node:fs";
 import { app } from "electron";
 
-// src/crypto/dec.ts
-import { createDecipheriv, createVerify } from "node:crypto";
-
-// 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/dec.ts
-function decrypt(encryptedText, key, iv) {
-  const decipher = createDecipheriv("aes-256-cbc", key, iv);
-  let decrypted = decipher.update(encryptedText, "base64url", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
-var verify = (buffer, signature, cert) => {
-  try {
-    const [sig, version] = decrypt(signature, hashString(cert, 32), hashString(buffer, 16)).split("%");
-    const result = createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
-    return result ? version : false;
-  } catch (error) {
-    return false;
-  }
-};
-
 // src/updater/types.ts
 var ErrorInfo = {
-  downlaod: "Download failed",
+  download: "Download failed",
   validate: "Validate failed",
   param: "Missing params",
   version: "Unsatisfied version"
@@ -59,83 +31,15 @@ var UpdaterError = class extends Error {
   }
 };
 
-// src/updater/defaultFunctions/download.ts
-import { net } from "electron";
-async function downlaodFn(url, headers, onResponse) {
-  await waitAppReady();
-  return new Promise((resolve2, reject) => {
-    const request = net.request({ url, method: "GET", redirect: "follow" });
-    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
-    request.on("response", (res) => onResponse(res, resolve2, reject));
-    request.on("error", reject);
-    request.end();
-  });
-}
-var downloadJSONDefault = async (url, headers) => {
-  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
-    let data = "";
-    resp.on("data", (chunk) => data += chunk);
-    resp.on("end", () => {
-      try {
-        const json = JSON.parse(data);
-        if (isUpdateJSON(json)) {
-          resolve2(json);
-        } else {
-          throw Error;
-        }
-      } catch (ignore) {
-        reject(new Error("invalid update json"));
-      }
-    });
-    resp.on("aborted", () => reject(new Error("aborted")));
-    resp.on("error", () => reject(new Error("download error")));
-  });
-};
-var downloadBufferDefault = async (url, headers, total, onDownloading) => {
-  let current = 0;
-  return await downlaodFn(url, headers, (resp, resolve2, reject) => {
-    let data = [];
-    resp.on("data", (chunk) => {
-      current += chunk.length;
-      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
-      data.push(chunk);
-    });
-    resp.on("end", () => resolve2(Buffer.concat(data)));
-    resp.on("aborted", () => reject(new Error("aborted")));
-    resp.on("error", () => reject(new Error("download error")));
-  });
-};
-
-// src/updater/defaultFunctions/compareVersion.ts
-var isLowerVersionDefault = (version1, version2) => {
-  const oldV = parseVersion(version1);
-  const newV = parseVersion(version2);
-  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;
-};
-
 // src/updater/core.ts
 var Updater = class {
-  CERT = __SIGNATURE_CERT__;
+  CERT = __EIU_SIGNATURE_CERT__;
   info;
-  option;
+  options;
   asarPath;
   gzipPath;
   tmpFilePath;
+  provider;
   /**
    * updater logger
    */
@@ -149,31 +53,49 @@ var Updater = class {
    * }
    */
   onDownloading;
+  /**
+   * URL handler hook
+   *
+   * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+   * @param url source url
+   * @param isDownloadAsar whether is download asar
+   */
+  handleURL;
   /**
    * whether receive beta version
    */
   get receiveBeta() {
-    return !!this.option.receiveBeta;
+    return !!this.options.receiveBeta;
   }
   set receiveBeta(receiveBeta) {
-    this.option.receiveBeta = receiveBeta;
+    this.options.receiveBeta = receiveBeta;
   }
   /**
    * initialize incremental updater
+   * @param provider update provider
    * @param option UpdaterOption
    */
-  constructor(option = {}) {
-    this.option = option;
+  constructor(provider, option = {}) {
+    this.provider = provider;
+    this.options = option;
     if (option.SIGNATURE_CERT) {
       this.CERT = option.SIGNATURE_CERT;
     }
+    if (option.logger) {
+      this.logger = option.logger;
+    }
     this.asarPath = getPathFromAppNameAsar();
     this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async needUpdate(version, minVersion) {
-    const isLowerVersion = this.option.overrideFunctions?.isLowerVersion ?? isLowerVersionDefault;
-    const { appVersion, entryVersion } = getVersions();
+    if (isDev) {
+      this.logger?.warn(`in dev mode, skip check update`);
+      return false;
+    }
+    const isLowerVersion = this.provider.isLowerVersion;
+    const entryVersion = getEntryVersion();
+    const appVersion = getAppVersion();
     if (await isLowerVersion(entryVersion, minVersion)) {
       throw new UpdaterError(ErrorInfo.version, `entry version (${entryVersion}) < minimumVersion (${minVersion})`);
     }
@@ -196,42 +118,14 @@ var Updater = class {
         throw new UpdaterError(ErrorInfo.param, `invalid type at format '${format}': ${JSON.stringify(data)}`);
       }
     }
-    const ua = this.option.downloadConfig?.userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
-    const headers = {
-      Accept: `application/${format === "json" ? "json" : "octet-stream"}`,
-      UserAgent: ua,
-      ...this.option.downloadConfig?.extraHeader
-    };
-    this.logger?.debug(`download headers: ${JSON.stringify(headers)}`);
-    const config = format === "json" ? {
-      name: "updateJsonURL",
-      url: this.option.updateJsonURL,
-      repoFallback: `${this.option.repository?.replace("github.com", "raw.githubusercontent.com")}/master/version.json`,
-      fn: this.option.overrideFunctions?.downloadJSON ?? downloadJSONDefault
-    } : {
-      name: "releaseAsarURL",
-      url: this.option.releaseAsarURL,
-      repoFallback: `${this.option.repository}/releases/download/v${this.info?.version}/${app.name}-${this.info?.version}.asar.gz`,
-      fn: this.option.overrideFunctions?.downloadBuffer ?? downloadBufferDefault
-    };
-    data ??= config.url;
-    if (!data) {
-      this.logger?.debug(`no ${config.name}, fallback to use repository`);
-      if (!this.option.repository) {
-        throw new UpdaterError(ErrorInfo.param, `${config.name} or repository is not set`);
-      }
-      if (format === "buffer" && !this.info?.version) {
-        throw new UpdaterError(ErrorInfo.param, "version is not set");
-      }
-      data = config.repoFallback;
-    }
-    this.logger?.debug(`download ${format} from ${data}`);
+    this.logger?.debug(`download from ${this.provider.name}`);
     try {
-      const ret = format === "json" ? await config.fn(data, headers) : await config.fn(data, headers, this.info.size, this.onDownloading);
-      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${ret.length}` : ""}`);
-      return ret;
+      const result = format === "json" ? await this.provider.downloadJSON(data ?? __EIU_VERSION_PATH__) : await this.provider.downloadBuffer(app.name, this.info, this.onDownloading);
+      this.logger?.debug(`download ${format} success${format === "buffer" ? `, file size: ${result.length}` : ""}`);
+      return result;
     } catch (e) {
-      throw new UpdaterError(ErrorInfo.downlaod, e.toString());
+      this.logger?.warn(`download ${format} failed: ${e}`);
+      throw new UpdaterError(ErrorInfo.download, `download ${format} failed: ${e}`);
     }
   }
   async checkUpdate(data) {
@@ -243,35 +137,32 @@ var Updater = class {
         minimumVersion = beta.minimumVersion;
         size = beta.size;
       }
-      this.logger?.debug(`checked version: ${version}, size: ${size}, signature: ${signature}`);
+      this.logger?.debug(`checked update, version: ${version}, size: ${size}, signature: ${signature}`);
       if (!await this.needUpdate(version, minimumVersion)) {
         this.logger?.info(`update unavailable: ${version} is the latest version`);
-        return void 0;
+        return { success: false, data: version };
       } else {
         this.logger?.info(`update available: ${version}`);
-        this.info = {
-          signature,
-          minimumVersion,
-          version,
-          size
-        };
-        return this.info;
+        this.info = { signature, minimumVersion, version, size };
+        return { success: true, data: this.info };
       }
     } catch (error) {
       this.logger?.error("check update failed", error);
-      return error;
+      return {
+        success: false,
+        data: error instanceof UpdaterError ? error : new UpdaterError(ErrorInfo.download, error.toString())
+      };
     }
   }
   async download(data, sig) {
     try {
-      const _sig = sig ?? this.info?.signature;
-      if (!_sig) {
-        throw new UpdaterError(ErrorInfo.param, "signature is empty");
+      if (!this.info) {
+        throw new UpdaterError(ErrorInfo.param, "no update info");
       }
+      const _sig = sig ?? this.info.signature;
       const buffer = await this.parseData("buffer", data);
       this.logger?.debug("verify start");
-      const _verify = this.option.overrideFunctions?.verifySignaure ?? verify;
-      const _ver = await _verify(buffer, _sig, this.CERT);
+      const _ver = await this.provider.verifySignaure(buffer, _sig, this.CERT);
       if (!_ver) {
         throw new UpdaterError(ErrorInfo.validate, "invalid signature or certificate");
       }
@@ -282,10 +173,13 @@ var Updater = class {
       await unzipFile(this.gzipPath, this.tmpFilePath);
       this.logger?.info(`download success, version: ${_ver}`);
       this.info = void 0;
-      return true;
+      return { success: true };
     } catch (error) {
       this.logger?.error("download asar failed", error);
-      return error;
+      return {
+        success: false,
+        data: error instanceof UpdaterError ? error : new UpdaterError(ErrorInfo.download, error.toString())
+      };
     }
   }
   /**
@@ -297,66 +191,53 @@ var Updater = class {
   }
 };
 
-// src/updater/index.ts
-function createUpdater(option) {
-  return new Updater(option);
-}
-
-// src/index.ts
+// 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 = {}) {
+async function initApp(appOptions) {
   const {
+    provider,
     updater,
-    electronDevDistPath = "../dist-electron",
-    mainPath = "main/index.js",
-    hooks
-  } = appOptions || {};
-  const {
     onInstall = defaultOnInstall,
     beforeStart,
     onStartError
-  } = hooks || {};
-  function handleError(err, logger2) {
-    console.error(err);
-    onStartError?.(err, logger2);
-    app2.quit();
-  }
+  } = appOptions;
   let updaterInstance;
   if (typeof updater === "object" || !updater) {
-    updaterInstance = createUpdater(updater);
+    updaterInstance = new Updater(provider, updater);
   } else {
     updaterInstance = await updater();
   }
-  const logger = updaterInstance.logger;
+  const logger = updaterInstance.logger || console;
   try {
     const appNameAsarPath = getPathFromAppNameAsar();
     const tempAsarPath = `${appNameAsarPath}.tmp`;
     if (existsSync2(tempAsarPath)) {
-      logger?.info(`installing new asar: ${tempAsarPath}`);
+      logger.info(`installing new asar: ${tempAsarPath}`);
       await onInstall(() => renameSync(tempAsarPath, appNameAsarPath), tempAsarPath, appNameAsarPath, logger);
     }
-    const mainDir = is.dev ? electronDevDistPath : appNameAsarPath;
-    const entry = resolve(__dirname, mainDir, mainPath);
-    await beforeStart?.(entry, logger);
-    __require(entry)(updaterInstance);
+    const mainFilePath = join(
+      isDev ? join(app2.getAppPath(), __EIU_MAIN_DEV_DIR__) : appNameAsarPath,
+      "main",
+      __EIU_MAIN_FILE__
+    );
+    await beforeStart?.(mainFilePath, logger);
+    __require(mainFilePath)(updaterInstance);
   } catch (error) {
-    handleError(error, logger);
+    logger.error("startup error", error);
+    onStartError?.(error, logger);
+    app2.quit();
   }
 }
 export {
   ErrorInfo,
   Updater,
   UpdaterError,
-  createUpdater,
-  downloadBufferDefault,
-  downloadJSONDefault,
   initApp,
-  isLowerVersionDefault,
   startupWithUpdater
 };

package/dist/provider.cjs

@@ -0,0 +1,227 @@
+"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);
+
+// src/provider/index.ts
+var provider_exports = {};
+__export(provider_exports, {
+  GitHubProvider: () => GitHubProvider,
+  downloadAsarBufferDefault: () => downloadAsarBufferDefault,
+  downloadUpdateJSONDefault: () => downloadUpdateJSONDefault
+});
+module.exports = __toCommonJS(provider_exports);
+
+// 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 waitAppReady(timeout = 1e3) {
+  return import_electron.app.isReady() ? Promise.resolve() : new Promise((resolve, reject) => {
+    const _ = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, timeout);
+    import_electron.app.whenReady().then(() => {
+      clearTimeout(_);
+      resolve();
+    });
+  });
+}
+
+// src/utils/zip.ts
+var import_node_fs2 = require("fs");
+var import_node_zlib = require("zlib");
+
+// src/utils/unzip.ts
+var import_node_fs3 = require("fs");
+var import_node_zlib2 = require("zlib");
+
+// src/utils/version.ts
+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 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 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, signature, cert) {
+  try {
+    const [sig, version] = decrypt(signature, 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");
+
+// src/provider/download.ts
+var import_electron2 = require("electron");
+async function downlaodFn(url, headers, onResponse) {
+  await waitAppReady();
+  return new Promise((resolve, reject) => {
+    const request = import_electron2.net.request({ url, method: "GET", redirect: "follow" });
+    Object.keys(headers).forEach((key) => request.setHeader(key, headers[key]));
+    request.on("response", (resp) => {
+      resp.on("aborted", () => reject(new Error("aborted")));
+      resp.on("error", () => reject(new Error("download error")));
+      onResponse(resp, resolve, reject);
+    });
+    request.on("error", reject);
+    request.end();
+  });
+}
+async function downloadUpdateJSONDefault(url, headers) {
+  return await downlaodFn(url, headers, (resp, resolve, reject) => {
+    let data = "";
+    resp.on("data", (chunk) => data += chunk);
+    resp.on("end", () => {
+      try {
+        const json = JSON.parse(data);
+        if (isUpdateJSON(json)) {
+          resolve(json);
+        } else {
+          throw Error;
+        }
+      } catch (ignore) {
+        reject(new Error("invalid update json"));
+      }
+    });
+  });
+}
+async function downloadAsarBufferDefault(url, headers, total, onDownloading) {
+  let current = 0;
+  return await downlaodFn(url, headers, (resp, resolve) => {
+    let data = [];
+    resp.on("data", (chunk) => {
+      current += chunk.length;
+      onDownloading?.({ percent: `${+(current / total).toFixed(2) * 100}%`, total, current });
+      data.push(chunk);
+    });
+    resp.on("end", () => resolve(Buffer.concat(data)));
+  });
+}
+
+// src/provider/github.ts
+var GitHubProvider = class {
+  ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36";
+  name = "GithubProvider";
+  urlHandler;
+  url;
+  extraHeaders;
+  constructor(options) {
+    this.url = new URL(options.url);
+    this.extraHeaders = options.extraHeaders;
+    this.urlHandler = options.urlHandler;
+    if (this.url.host !== "github.com") {
+      throw new Error(`${this.name}: invalid github url: ${options.url}`);
+    }
+    if (!this.url.pathname.endsWith("/")) {
+      this.url.pathname += "/";
+    }
+  }
+  parseURL(isDownloadAsar, path) {
+    const url = this.url.href + path;
+    return this.urlHandler ? this.urlHandler(url, isDownloadAsar) : url;
+  }
+  isLowerVersion = isLowerVersionDefault;
+  verifySignaure = verifySignatureDefault;
+  async downloadJSON(versionPath) {
+    return await downloadUpdateJSONDefault(
+      this.parseURL(false, `HEAD/${versionPath}`),
+      { userAgent: this.ua, accept: "application/json", ...this.extraHeaders }
+    );
+  }
+  async downloadBuffer(name, { version, size }, onDownloading) {
+    return await downloadAsarBufferDefault(
+      this.parseURL(true, `releases/download/v${version}/${name}-${version}.asar.gz`),
+      { userAgent: this.ua, accept: "application/octet-stream", ...this.extraHeaders },
+      size,
+      onDownloading
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GitHubProvider,
+  downloadAsarBufferDefault,
+  downloadUpdateJSONDefault
+});

package/dist/provider.d.cts

@@ -0,0 +1,37 @@
+import { i as isLowerVersionDefault, U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.cjs';
+import { v as verifySignatureDefault } from './decrypt-BNBcodiO.cjs';
+import { U as URLHandler, I as IProvider, D as DownloadingInfo, O as OnDownloading } from './types-DxPmQmaq.cjs';
+import '@subframe7536/type-utils';
+
+interface GitHubProviderOptions {
+    /**
+     * github repo root url
+     * @example 'https://github.com/electron/electron'
+     */
+    url: string;
+    extraHeaders?: Record<string, string>;
+    /**
+     * custom url handler
+     *
+     * for Github, there are some {@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34 public CDN links}
+     */
+    urlHandler?: URLHandler;
+}
+declare class GitHubProvider implements IProvider {
+    private ua;
+    name: string;
+    urlHandler?: URLHandler;
+    private url;
+    private extraHeaders?;
+    constructor(options: GitHubProviderOptions);
+    private parseURL;
+    isLowerVersion: typeof isLowerVersionDefault;
+    verifySignaure: typeof verifySignatureDefault;
+    downloadJSON(versionPath: string): Promise<UpdateJSON>;
+    downloadBuffer(name: string, { version, size }: UpdateInfo, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
+
+declare function downloadUpdateJSONDefault(url: string, headers: Record<string, any>): Promise<UpdateJSON>;
+declare function downloadAsarBufferDefault(url: string, headers: Record<string, any>, total: number, onDownloading?: OnDownloading): Promise<Buffer>;
+
+export { DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, downloadAsarBufferDefault, downloadUpdateJSONDefault };