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

package/dist/provider.cjs

@@ -1,58 +1,17 @@
-"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/provider/index.ts
-var provider_exports = {};
-__export(provider_exports, {
-  GitHubProvider: () => GitHubProvider,
-  downloadAsarBufferDefault: () => downloadAsarBufferDefault,
-  downloadUpdateJSONDefault: () => downloadUpdateJSONDefault
-});
-module.exports = __toCommonJS(provider_exports);
+var url = require('url');
+var electron = require('electron');
+var crypto = require('crypto');
+var zlib = require('zlib');
 
-// 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();
-    });
-  });
-}
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// src/utils/zip.ts
-var import_node_fs2 = require("fs");
-var import_node_zlib = require("zlib");
+var electron__default = /*#__PURE__*/_interopDefault(electron);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var zlib__default = /*#__PURE__*/_interopDefault(zlib);
 
-// src/utils/unzip.ts
-var import_node_fs3 = require("fs");
-var import_node_zlib2 = require("zlib");
+// src/provider/github.ts
 
 // src/utils/version.ts
 function parseVersion(version) {
@@ -74,11 +33,11 @@ function parseVersion(version) {
     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}`);
+    throw new TypeError(`Invalid version: ${version}`);
   }
   return ret;
 }
-function isLowerVersionDefault(oldVer, newVer) {
+function defaultIsLowerVersion(oldVer, newVer) {
   const oldV = parseVersion(oldVer);
   const newV = parseVersion(newVer);
   function compareStrings(str1, str2) {
@@ -99,47 +58,24 @@ function isLowerVersionDefault(oldVer, newVer) {
   return false;
 }
 function isUpdateJSON(json) {
-  const is = (j) => !!(j && j.minimumVersion && j.signature && j.size && j.version);
+  const is = (j) => !!(j && j.minimumVersion && j.signature && 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/provider/download.ts
+function getHeader(headers, key) {
+  const value = headers[key];
+  if (Array.isArray(value)) {
+    return value.length === 0 ? null : value[value.length - 1];
+  } else {
+    return value;
   }
 }
-
-// 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();
+async function downloadFn(url, headers, signal, onResponse) {
+  await electron__default.default.app.whenReady();
   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]));
+    const request = electron__default.default.net.request({ url, method: "GET", redirect: "follow", headers, cache: "no-cache" });
+    signal.addEventListener("abort", () => request.abort(), { once: true });
     request.on("response", (resp) => {
       resp.on("aborted", () => reject(new Error("aborted")));
       resp.on("error", () => reject(new Error("download error")));
@@ -149,79 +85,162 @@ async function downlaodFn(url, headers, onResponse) {
     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;
+async function defaultDownloadUpdateJSON(url, headers, signal) {
+  return await downloadFn(
+    url,
+    headers,
+    signal,
+    (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 {
+          reject(new Error("invalid update json " + data));
         }
-      } catch (ignore) {
-        reject(new Error("invalid update json"));
-      }
-    });
-  });
+      });
+    }
+  );
+}
+async function defaultDownloadAsar(url, headers, signal, onDownloading) {
+  let transferred = 0;
+  let time = Date.now();
+  return await downloadFn(
+    url,
+    headers,
+    signal,
+    (resp, resolve) => {
+      const total = +getHeader(resp.headers, "content-length") || -1;
+      let data = [];
+      resp.on("data", (chunk) => {
+        const delta = chunk.length;
+        transferred += delta;
+        const current = Date.now();
+        onDownloading?.({
+          percent: total ? +(transferred / total).toFixed(2) * 100 : -1,
+          total,
+          transferred,
+          delta,
+          bps: delta / ((current - time) * 1e3)
+        });
+        time = current;
+        data.push(chunk);
+      });
+      resp.on("end", () => resolve(Buffer.concat(data)));
+    }
+  );
+}
+function hashBuffer(data, length) {
+  const hash = crypto__default.default.createHash("SHA256").update(data).digest("binary");
+  return Buffer.from(hash).subarray(0, length);
+}
+function aesDecrypt(encryptedText, key, iv) {
+  const decipher = crypto__default.default.createDecipheriv("aes-256-cbc", key, iv);
+  return decipher.update(encryptedText, "base64url", "utf8") + decipher.final("utf8");
+}
+function defaultVerifySignature(buffer, version, signature, cert) {
+  try {
+    const [sig, ver] = aesDecrypt(signature, hashBuffer(cert, 32), hashBuffer(buffer, 16)).split("%");
+    if (ver !== version) {
+      return false;
+    }
+    return crypto__default.default.createVerify("RSA-SHA256").update(buffer).verify(cert, sig, "base64");
+  } catch {
+    return false;
+  }
 }
-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);
+async function defaultUnzipFile(buffer) {
+  return new Promise((resolve, reject) => {
+    zlib__default.default.brotliDecompress(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(buffer2);
+      }
     });
-    resp.on("end", () => resolve(Buffer.concat(data)));
   });
 }
 
+// src/provider/base.ts
+var BaseProvider = class {
+  name = "BaseProvider";
+  /**
+   * @inheritdoc
+   */
+  isLowerVersion = defaultIsLowerVersion;
+  /**
+   * @inheritdoc
+   */
+  verifySignaure = defaultVerifySignature;
+  /**
+   * @inheritdoc
+   */
+  unzipFile = defaultUnzipFile;
+};
+
 // 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";
+var GitHubProvider = class extends BaseProvider {
   name = "GithubProvider";
-  urlHandler;
-  url;
-  extraHeaders;
+  options;
+  /**
+   * Update Provider for Github repo
+   * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+   * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+   *
+   * you can setup `urlHandler` in {@link GitHubProviderOptions} to modify url before request
+   * @param options provider options
+   */
   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 += "/";
+    super();
+    this.options = options;
+    if (!options.branch) {
+      this.options.branch = "HEAD";
     }
   }
-  parseURL(isDownloadAsar, path) {
-    const url = this.url.href + path;
-    return this.urlHandler ? this.urlHandler(url, isDownloadAsar) : url;
+  get urlHandler() {
+    return this.options.urlHandler;
+  }
+  set urlHandler(handler) {
+    this.options.urlHandler = handler;
   }
-  isLowerVersion = isLowerVersionDefault;
-  verifySignaure = verifySignatureDefault;
-  async downloadJSON(versionPath) {
-    return await downloadUpdateJSONDefault(
-      this.parseURL(false, `HEAD/${versionPath}`),
-      { userAgent: this.ua, accept: "application/json", ...this.extraHeaders }
+  async parseURL(isDownloadAsar, extraPath) {
+    const url$1 = new url.URL(
+      `/${this.options.user}/${this.options.repo}/${extraPath}`,
+      "https://" + (isDownloadAsar ? "github.com" : "raw.githubusercontent.com")
     );
+    return (await this.urlHandler?.(url$1, isDownloadAsar) || url$1).toString();
   }
-  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,
+  /**
+   * @inheritdoc
+   */
+  async downloadJSON(versionPath, signal) {
+    return await defaultDownloadUpdateJSON(
+      await this.parseURL(false, `${this.options.branch}/${versionPath}`),
+      { Accept: "application/json", ...this.options.extraHeaders },
+      signal
+    );
+  }
+  /**
+   * @inheritdoc
+   */
+  async downloadAsar(name, info, signal, onDownloading) {
+    return await defaultDownloadAsar(
+      await this.parseURL(true, `releases/download/v${info.version}/${name}-${info.version}.asar.gz`),
+      { Accept: "application/octet-stream", ...this.options.extraHeaders },
+      signal,
       onDownloading
     );
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GitHubProvider,
-  downloadAsarBufferDefault,
-  downloadUpdateJSONDefault
-});
+
+exports.BaseProvider = BaseProvider;
+exports.GitHubProvider = GitHubProvider;
+exports.defaultDownloadAsar = defaultDownloadAsar;
+exports.defaultDownloadUpdateJSON = defaultDownloadUpdateJSON;
+exports.getHeader = getHeader;

package/dist/provider.d.cts

@@ -1,37 +1,109 @@
-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';
+import { d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo } from './version-BYVQ367i.cjs';
+import { I as IProvider, D as DownloadingInfo, U as URLHandler, O as OnDownloading } from './types-CGSkHX4Y.cjs';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-rm9ED9nU.cjs';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    /**
+     * @inheritdoc
+     */
+    isLowerVersion: typeof defaultIsLowerVersion;
+    /**
+     * @inheritdoc
+     */
+    verifySignaure: typeof defaultVerifySignature;
+    /**
+     * @inheritdoc
+     */
+    unzipFile: typeof defaultUnzipFile;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadJSON(versionPath: string, signal: AbortSignal): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadAsar(name: string, info: UpdateInfo, signal: AbortSignal, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
 
 interface GitHubProviderOptions {
     /**
-     * github repo root url
-     * @example 'https://github.com/electron/electron'
+     * Github user name
+     */
+    user: string;
+    /**
+     * Github repo name
+     */
+    repo: string;
+    /**
+     * Github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * Extra headers
      */
-    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}
+     * Custom url handler ({@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L40 some public CDN links})
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
      */
     urlHandler?: URLHandler;
 }
-declare class GitHubProvider implements IProvider {
-    private ua;
+declare class GitHubProvider extends BaseProvider {
     name: string;
-    urlHandler?: URLHandler;
-    private url;
-    private extraHeaders?;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} to modify url before request
+     * @param options provider options
+     */
     constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
     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>;
+    /**
+     * @inheritdoc
+     */
+    downloadJSON(versionPath: string, signal: AbortSignal): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    downloadAsar(name: string, info: UpdateInfo, signal: AbortSignal, 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>;
+/**
+ * Safe get value from header
+ * @param headers response header
+ * @param key target header key
+ */
+declare function getHeader(headers: Record<string, Arrayable<string>>, key: any): any;
+/**
+ * Default function to download json and parse to UpdateJson
+ * @param url target url
+ * @param headers extra headers
+ * @param signal abort signal
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>, signal: AbortSignal): Promise<UpdateJSON>;
+/**
+ * Default function to download asar buffer,
+ * get total size from `Content-Length` header
+ * @param url target url
+ * @param headers extra headers
+ * @param signal abort signal
+ * @param onDownloading on downloading callback
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, signal: AbortSignal, onDownloading?: OnDownloading): Promise<Buffer>;
 
-export { DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, downloadAsarBufferDefault, downloadUpdateJSONDefault };
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };

package/dist/provider.d.ts

@@ -1,37 +1,109 @@
-import { i as isLowerVersionDefault, U as UpdateJSON, a as UpdateInfo } from './version-CffZWDhZ.js';
-import { v as verifySignatureDefault } from './decrypt-BNBcodiO.js';
-import { U as URLHandler, I as IProvider, D as DownloadingInfo, O as OnDownloading } from './types-seJf3Wbc.js';
-import '@subframe7536/type-utils';
+import { d as defaultIsLowerVersion, a as UpdateJSON, U as UpdateInfo } from './version-BYVQ367i.js';
+import { I as IProvider, D as DownloadingInfo, U as URLHandler, O as OnDownloading } from './types-C8JhnJjU.js';
+import { f as defaultVerifySignature, a as defaultUnzipFile } from './zip-rm9ED9nU.js';
+import { Arrayable } from '@subframe7536/type-utils';
+
+declare abstract class BaseProvider implements IProvider {
+    name: string;
+    /**
+     * @inheritdoc
+     */
+    isLowerVersion: typeof defaultIsLowerVersion;
+    /**
+     * @inheritdoc
+     */
+    verifySignaure: typeof defaultVerifySignature;
+    /**
+     * @inheritdoc
+     */
+    unzipFile: typeof defaultUnzipFile;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadJSON(versionPath: string, signal: AbortSignal): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    abstract downloadAsar(name: string, info: UpdateInfo, signal: AbortSignal, onDownloading?: (info: DownloadingInfo) => void): Promise<Buffer>;
+}
 
 interface GitHubProviderOptions {
     /**
-     * github repo root url
-     * @example 'https://github.com/electron/electron'
+     * Github user name
+     */
+    user: string;
+    /**
+     * Github repo name
+     */
+    repo: string;
+    /**
+     * Github branch name that fetch version
+     * @default 'HEAD'
+     */
+    branch?: string;
+    /**
+     * Extra headers
      */
-    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}
+     * Custom url handler ({@link https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L40 some public CDN links})
+     * @example
+     * (url, isDownloadAsar) => {
+     *   if (isDownloadAsar) {
+     *     url.hostname = 'mirror.ghproxy.com'
+     *     url.pathname = 'https://github.com' + url.pathname
+     *     return url
+     *   }
+     * }
      */
     urlHandler?: URLHandler;
 }
-declare class GitHubProvider implements IProvider {
-    private ua;
+declare class GitHubProvider extends BaseProvider {
     name: string;
-    urlHandler?: URLHandler;
-    private url;
-    private extraHeaders?;
+    private options;
+    /**
+     * Update Provider for Github repo
+     * - download update json from `https://raw.githubusercontent.com/{user}/{repo}/HEAD/{versionPath}`
+     * - download update asar from `https://github.com/{user}/{repo}/releases/download/v{version}/{name}-{version}.asar.gz`
+     *
+     * you can setup `urlHandler` in {@link GitHubProviderOptions} to modify url before request
+     * @param options provider options
+     */
     constructor(options: GitHubProviderOptions);
+    get urlHandler(): URLHandler | undefined;
+    set urlHandler(handler: URLHandler);
     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>;
+    /**
+     * @inheritdoc
+     */
+    downloadJSON(versionPath: string, signal: AbortSignal): Promise<UpdateJSON>;
+    /**
+     * @inheritdoc
+     */
+    downloadAsar(name: string, info: UpdateInfo, signal: AbortSignal, 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>;
+/**
+ * Safe get value from header
+ * @param headers response header
+ * @param key target header key
+ */
+declare function getHeader(headers: Record<string, Arrayable<string>>, key: any): any;
+/**
+ * Default function to download json and parse to UpdateJson
+ * @param url target url
+ * @param headers extra headers
+ * @param signal abort signal
+ */
+declare function defaultDownloadUpdateJSON(url: string, headers: Record<string, any>, signal: AbortSignal): Promise<UpdateJSON>;
+/**
+ * Default function to download asar buffer,
+ * get total size from `Content-Length` header
+ * @param url target url
+ * @param headers extra headers
+ * @param signal abort signal
+ * @param onDownloading on downloading callback
+ */
+declare function defaultDownloadAsar(url: string, headers: Record<string, any>, signal: AbortSignal, onDownloading?: OnDownloading): Promise<Buffer>;
 
-export { DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, downloadAsarBufferDefault, downloadUpdateJSONDefault };
+export { BaseProvider, DownloadingInfo, GitHubProvider, type GitHubProviderOptions, IProvider, OnDownloading, URLHandler, defaultDownloadAsar, defaultDownloadUpdateJSON, getHeader };