electron-incremental-update 0.8.5 → 0.8.7

package/README.md

@@ -51,25 +51,25 @@ src
 
 ```ts
 // electron/app.ts
-import { getGithubReleaseCdnGroup, initApp, parseGithubCdnURL } from 'electron-incremental-update'
+import { initApp, parseGithubCdnURL } from 'electron-incremental-update'
 import { name, repository } from '../package.json'
 
 const SIGNATURE_CERT = '' // auto generate certificate when start app
 
-const { cdnPrefix: asarPrefix } = getGithubReleaseCdnGroup()[0]
-const { cdnPrefix: jsonPrefix } = getGithubFileCdnGroup()[0]
 initApp({ onStart: console.log })
   // can be updater option or function that return updater
   .setUpdater({
     SIGNATURE_CERT,
     productName: name,
     repository,
-    updateJsonURL: parseGithubCdnURL(repository, jsonPrefix, 'version.json'),
-    releaseAsarURL: parseGithubCdnURL(repository, asarPrefix, `download/latest/${name}.asar.gz`),
+    updateJsonURL: parseGithubCdnURL(repository, '...', 'version.json'),
+    releaseAsarURL: parseGithubCdnURL(repository, '...', `download/latest/${name}.asar.gz`),
     receiveBeta: true
   })
 ```
 
+- [some cdn resources](https://github.com/XIU2/UserScript/blob/master/GithubEnhanced-High-Speed-Download.user.js#L34):
+
 ### setup vite.config.ts
 
 make sure the plugin is set in the **last** build task
@@ -121,7 +121,7 @@ export default defineConfig(({ command }) => {
 ```json
 {
   // ...
-  "main": "app.js" // <- app entry file
+  "main": "app.js" // <- app entry file path
 }
 ```
 
@@ -174,7 +174,7 @@ However, you have the option to customize the download function when creating th
 ```ts
 // electron/main/index.ts
 import type { StartupWithUpdater, Updater } from 'electron-incremental-update'
-import { getEntryVersion, getProductAsarPath, getProductVersion } from 'electron-incremental-update'
+import { appInfo, getProductAsarPath } from 'electron-incremental-update/utils'
 import { app } from 'electron'
 import { name } from '../../package.json'
 
@@ -182,8 +182,8 @@ const startup: StartupWithUpdater = (updater: Updater) => {
   await app.whenReady()
   console.log('\ncurrent:')
   console.log(`\tasar path: ${getProductAsarPath(name)}`)
-  console.log(`\tentry:     ${getEntryVersion()}`)
-  console.log(`\tapp:       ${getProductVersion(name)}`)
+  console.log(`\tapp:       ${appInfo.appVersion(name)}`)
+  console.log(`\telectron:  ${appInfo.electronVersion}`)
   updater.onDownloading = ({ percent }) => {
     console.log(percent)
   }
@@ -209,11 +209,18 @@ export default startup
 
 ### use native modules
 
+the native modules is packed in `app.asar`, so you cannot directly access it when in production
+
+to use it, you can prebundle native modules, or use `requireNative` to load.
+
 ```ts
 // db.ts
-import { requireNative } from 'electron-incremental-update'
+import { isNoSuchNativeModuleError, requireNative } from 'electron-incremental-update/utils'
 
 const Database = requireNative<typeof import('better-sqlite3')>('better-sqlite3')
+if (isNoSuchNativeModuleError(Database)) {
+  // ...
+}
 const db = new Database(':memory:')
 db.exec(
   'DROP TABLE IF EXISTS employees; '

package/dist/{chunk-GXZSAUBR.mjs → chunk-5BZLJPHJ.mjs}

@@ -30,7 +30,14 @@ var verify = (buffer, signature2, cert) => {
   }
 };
 
+// src/updateJson.ts
+function isUpdateJSON(json) {
+  const is = (j) => "signature" in j && "version" in j && "size" in j && "minimumVersion" in j;
+  return is(json) && "beta" in json && is(json.beta);
+}
+
 export {
   signature,
-  verify
+  verify,
+  isUpdateJSON
 };

package/dist/chunk-CMBFI77K.mjs

@@ -0,0 +1,75 @@
+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 parseVersion(version) {
+  const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
+  const match = semver.exec(version);
+  if (!match) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  const [major, minor, patch] = match.slice(1, 4).map(Number);
+  const ret = {
+    major,
+    minor,
+    patch,
+    stage: "",
+    stageVersion: -1
+  };
+  if (match[4]) {
+    let [stage, _v] = match[4].split(".");
+    ret.stage = stage;
+    ret.stageVersion = Number(_v) || -1;
+  }
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch) || Number.isNaN(ret.stageVersion)) {
+    throw new TypeError(`invalid version: ${version}`);
+  }
+  return ret;
+}
+
+// src/utils/zip.ts
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { gunzip, gzip } from "node:zlib";
+async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
+  if (!existsSync(gzipPath)) {
+    throw new Error(`path to zipped file not exist: ${gzipPath}`);
+  }
+  const compressedBuffer = readFileSync(gzipPath);
+  return new Promise((resolve, reject) => {
+    gunzip(compressedBuffer, (err, buffer) => {
+      rmSync(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer);
+      resolve(null);
+    });
+  });
+}
+async function zipFile(filePath, targetFilePath = `${filePath}.gz`) {
+  if (!existsSync(filePath)) {
+    throw new Error(`path to be zipped not exist: ${filePath}`);
+  }
+  const buffer = readFileSync(filePath);
+  return new Promise((resolve, reject) => {
+    gzip(buffer, (err, buffer2) => {
+      if (err) {
+        reject(err);
+      }
+      writeFileSync(targetFilePath, buffer2);
+      resolve(null);
+    });
+  });
+}
+
+export {
+  __require,
+  parseVersion,
+  unzipFile,
+  zipFile
+};

package/dist/chunk-OGAOUYV3.mjs

@@ -0,0 +1,99 @@
+import {
+  __require
+} from "./chunk-CMBFI77K.mjs";
+
+// src/utils/core.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { release } from "node:os";
+import { app } from "electron";
+var DEFAULT_APP_NAME = "product";
+var appInfo = {
+  dev: !app.isPackaged,
+  win: process.platform === "win32",
+  mac: process.platform === "darwin",
+  linux: process.platform === "linux",
+  electronVersion: getElectronVersion(),
+  appVersion: getAppVersion,
+  systemVersion: release()
+};
+function getLocale() {
+  return app.isReady() ? app.getLocale() : void 0;
+}
+function getProductAsarPath(name = DEFAULT_APP_NAME) {
+  return !app.isPackaged ? "DEV.asar" : join(dirname(app.getAppPath()), `${name}.asar`);
+}
+function getElectronVersion() {
+  return app.getVersion();
+}
+function getAppVersion(name = DEFAULT_APP_NAME) {
+  return app.isPackaged ? readFileSync(join(getProductAsarPath(name), "version"), "utf-8") : getElectronVersion();
+}
+var NoSuchNativeModuleError = class extends Error {
+  moduleName;
+  constructor(moduleName) {
+    super(`no such native module: ${moduleName}`);
+    this.moduleName = moduleName;
+  }
+};
+function isNoSuchNativeModuleError(e) {
+  return e instanceof NoSuchNativeModuleError;
+}
+function requireNative(packageName) {
+  const path = app.isPackaged ? join(app.getAppPath(), "node_modules", packageName) : packageName;
+  try {
+    return __require(path);
+  } catch (error) {
+    return new NoSuchNativeModuleError(packageName);
+  }
+}
+
+// src/utils/utils.ts
+import { app as app2 } from "electron";
+function parseGithubCdnURL(originRepoURL, cdnPrefix, relativeFilePath) {
+  if (!originRepoURL.startsWith("https://github.com/")) {
+    throw new Error("origin url must start with https://github.com/");
+  }
+  originRepoURL = originRepoURL.trim().replace(/\/?$/, "/").trim();
+  relativeFilePath = relativeFilePath.trim().replace(/^\/|\/?$/g, "").trim();
+  cdnPrefix = cdnPrefix.trim().replace(/^\/?|\/?$/g, "").trim();
+  return originRepoURL.replace("github.com", cdnPrefix) + relativeFilePath;
+}
+function restartApp() {
+  app2.relaunch();
+  app2.quit();
+}
+function waitAppReady(duration = 1e3) {
+  if (app2.isReady()) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, duration);
+    app2.whenReady().then(() => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+function handleUnexpectedErrors(callback) {
+  process.on("uncaughtException", callback);
+  process.on("unhandledRejection", callback);
+}
+
+export {
+  DEFAULT_APP_NAME,
+  appInfo,
+  getLocale,
+  getProductAsarPath,
+  getElectronVersion,
+  getAppVersion,
+  NoSuchNativeModuleError,
+  isNoSuchNativeModuleError,
+  requireNative,
+  parseGithubCdnURL,
+  restartApp,
+  waitAppReady,
+  handleUnexpectedErrors
+};

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { UpdateJSON } from './updateJson.mjs';
+import { U as UpdateJSON } from './updateJson-7e45d9e1.js';
 
 declare class MinimumVersionError extends Error {
     currentVersion: string;
@@ -141,11 +141,11 @@ interface UpdaterOption {
      */
     SIGNATURE_CERT: string;
     /**
-     * name of your application
+     * name of your application, you can use the `name` in `package.json`
      *
-     * you can use the `name` in `package.json`
+     * @default DEFAULT_APP_NAME
      */
-    productName: string;
+    productName?: string;
     /**
      * repository url, e.g. `https://github.com/electron/electron`
      *
@@ -184,7 +184,6 @@ declare class IncrementalUpdater implements Updater {
     logger?: Logger;
     onDownloading?: (progress: DownloadingInfo) => void;
     get productName(): string;
-    set productName(name: string);
     get receiveBeta(): boolean;
     set receiveBeta(receiveBeta: boolean);
     constructor(option: UpdaterOption);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { UpdateJSON } from './updateJson.js';
+import { U as UpdateJSON } from './updateJson-7e45d9e1.js';
 
 declare class MinimumVersionError extends Error {
     currentVersion: string;
@@ -141,11 +141,11 @@ interface UpdaterOption {
      */
     SIGNATURE_CERT: string;
     /**
-     * name of your application
+     * name of your application, you can use the `name` in `package.json`
      *
-     * you can use the `name` in `package.json`
+     * @default DEFAULT_APP_NAME
      */
-    productName: string;
+    productName?: string;
     /**
      * repository url, e.g. `https://github.com/electron/electron`
      *
@@ -184,7 +184,6 @@ declare class IncrementalUpdater implements Updater {
     logger?: Logger;
     onDownloading?: (progress: DownloadingInfo) => void;
     get productName(): string;
-    set productName(name: string);
     get receiveBeta(): boolean;
     set receiveBeta(receiveBeta: boolean);
     constructor(option: UpdaterOption);

package/dist/index.js

@@ -36,59 +36,39 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_node_path2 = require("path");
-var import_node_fs3 = require("fs");
-var import_electron3 = __toESM(require("electron"));
+var import_node_fs4 = require("fs");
+var import_electron4 = __toESM(require("electron"));
 
 // src/updater/index.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
 
-// src/utils.ts
+// src/utils/core.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_node_zlib = require("zlib");
-var import_electron = __toESM(require("electron"));
-var info = {
-  dev: !import_electron.default.app?.isPackaged,
-  platform: process.platform === "win32" ? "win" : process.platform === "darwin" ? "mac" : "linux",
-  appPath: import_electron.default.app?.getAppPath()
+var import_node_os = require("os");
+var import_electron = require("electron");
+var DEFAULT_APP_NAME = "product";
+var appInfo = {
+  dev: !import_electron.app.isPackaged,
+  win: process.platform === "win32",
+  mac: process.platform === "darwin",
+  linux: process.platform === "linux",
+  electronVersion: getElectronVersion(),
+  appVersion: getAppVersion,
+  systemVersion: (0, import_node_os.release)()
 };
-function getProductAsarPath(name) {
-  return info.dev ? "dev.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(info.appPath), `${name}.asar`);
+function getProductAsarPath(name = DEFAULT_APP_NAME) {
+  return !import_electron.app.isPackaged ? "DEV.asar" : (0, import_node_path.join)((0, import_node_path.dirname)(import_electron.app.getAppPath()), `${name}.asar`);
 }
-function getEntryVersion() {
-  return import_electron.default.app.getVersion();
-}
-function getProductVersion(name) {
-  return info.dev ? getEntryVersion() : (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8");
-}
-function waitAppReady(duration = 1e3) {
-  return new Promise((resolve2, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error("app is not ready"));
-    }, duration);
-    import_electron.default.app.whenReady().then(() => {
-      clearTimeout(timeout);
-      resolve2();
-    });
-  });
+function getElectronVersion() {
+  return import_electron.app.getVersion();
 }
-async function unzipFile(gzipPath, targetFilePath = gzipPath.slice(0, -3)) {
-  if (!(0, import_node_fs.existsSync)(gzipPath)) {
-    throw new Error(`path to zipped file not exist: ${gzipPath}`);
-  }
-  const compressedBuffer = (0, import_node_fs.readFileSync)(gzipPath);
-  return new Promise((resolve2, reject) => {
-    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
-      (0, import_node_fs.rmSync)(gzipPath);
-      if (err) {
-        reject(err);
-      }
-      (0, import_node_fs.writeFileSync)(targetFilePath, buffer);
-      resolve2(null);
-    });
-  });
+function getAppVersion(name = DEFAULT_APP_NAME) {
+  return import_electron.app.isPackaged ? (0, import_node_fs.readFileSync)((0, import_node_path.join)(getProductAsarPath(name), "version"), "utf-8") : getElectronVersion();
 }
+
+// src/utils/version.ts
 function parseVersion(version) {
   const semver = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9\.-]+))?/i;
   const match = semver.exec(version);
@@ -114,6 +94,43 @@ function parseVersion(version) {
   return ret;
 }
 
+// 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}`);
+  }
+  const compressedBuffer = (0, import_node_fs2.readFileSync)(gzipPath);
+  return new Promise((resolve2, reject) => {
+    (0, import_node_zlib.gunzip)(compressedBuffer, (err, buffer) => {
+      (0, import_node_fs2.rmSync)(gzipPath);
+      if (err) {
+        reject(err);
+      }
+      (0, import_node_fs2.writeFileSync)(targetFilePath, buffer);
+      resolve2(null);
+    });
+  });
+}
+
+// src/utils/utils.ts
+var import_electron2 = require("electron");
+function waitAppReady(duration = 1e3) {
+  if (import_electron2.app.isReady()) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("app is not ready"));
+    }, duration);
+    import_electron2.app.whenReady().then(() => {
+      clearTimeout(timeout);
+      resolve2();
+    });
+  });
+}
+
 // src/crypto.ts
 var import_node_crypto = require("crypto");
 function decrypt(encryptedText, key2, iv) {
@@ -168,11 +185,11 @@ var DownloadError = class extends Error {
 };
 
 // src/updater/defaultFunctions.ts
-var import_electron2 = __toESM(require("electron"));
+var import_electron3 = require("electron");
 var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
-    const request = import_electron2.default.net.request({
+    const request = import_electron3.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -206,7 +223,7 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
   await waitAppReady();
   let current = 0;
   return new Promise((resolve2, reject) => {
-    const request = import_electron2.default.net.request({
+    const request = import_electron3.net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -267,9 +284,6 @@ var IncrementalUpdater = class {
   get productName() {
     return this.option.productName;
   }
-  set productName(name) {
-    this.option.productName = name;
-  }
   get receiveBeta() {
     return !!this.option.receiveBeta;
   }
@@ -278,14 +292,17 @@ var IncrementalUpdater = class {
   }
   constructor(option) {
     this.option = option;
+    if (!option.productName) {
+      this.option.productName = DEFAULT_APP_NAME;
+    }
     this.asarPath = getProductAsarPath(this.productName);
     this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async needUpdate(version, minVersion) {
     const compare = this.option.overrideFunctions?.compareVersion ?? compareVersionDefault;
-    const productVersion = getProductVersion(this.option.productName);
-    const entryVersion = getEntryVersion();
+    const productVersion = getAppVersion(this.option.productName);
+    const entryVersion = getElectronVersion();
     if (await compare(entryVersion, minVersion)) {
       throw new MinimumVersionError(entryVersion, minVersion);
     }
@@ -293,11 +310,11 @@ var IncrementalUpdater = class {
     return await compare(productVersion, version);
   }
   async parseData(format, data) {
-    if ((0, import_node_fs2.existsSync)(this.tmpFilePath)) {
+    if ((0, import_node_fs3.existsSync)(this.tmpFilePath)) {
       this.logger?.warn(`remove tmp file: ${this.tmpFilePath}`);
       await (0, import_promises.rm)(this.tmpFilePath);
     }
-    if ((0, import_node_fs2.existsSync)(this.gzipPath)) {
+    if ((0, import_node_fs3.existsSync)(this.gzipPath)) {
       this.logger?.warn(`remove .gz file: ${this.gzipPath}`);
       await (0, import_promises.rm)(this.gzipPath);
     }
@@ -421,17 +438,17 @@ function initApp(appOptions) {
   } = hooks || {};
   function handleError(msg) {
     onStartError?.(new Error(msg));
-    import_electron3.default.app.quit();
+    import_electron4.default.app.quit();
   }
   async function startup(updater) {
     try {
       const asarPath = getProductAsarPath(updater.productName);
       const updateAsarPath = `${asarPath}.tmp`;
-      if ((0, import_node_fs3.existsSync)(updateAsarPath)) {
+      if ((0, import_node_fs4.existsSync)(updateAsarPath)) {
         await beforeDoUpdate?.(asarPath, updateAsarPath);
-        (0, import_node_fs3.renameSync)(updateAsarPath, asarPath);
+        (0, import_node_fs4.renameSync)(updateAsarPath, asarPath);
       }
-      const mainDir = import_electron3.default.app.isPackaged ? asarPath : electronDevDistPath;
+      const mainDir = import_electron4.default.app.isPackaged ? asarPath : electronDevDistPath;
       const entry = (0, import_node_path2.resolve)(__dirname, mainDir, mainPath);
       await beforeStart?.(entry);
       require(entry)(updater);

package/dist/index.mjs

@@ -1,25 +1,24 @@
 import {
+  isUpdateJSON,
   verify
-} from "./chunk-GXZSAUBR.mjs";
+} from "./chunk-5BZLJPHJ.mjs";
 import {
-  getEntryVersion,
+  DEFAULT_APP_NAME,
+  getAppVersion,
+  getElectronVersion,
   getProductAsarPath,
-  getProductVersion,
-  parseVersion,
-  unzipFile,
   waitAppReady
-} from "./chunk-CR6HTU6P.mjs";
-import {
-  isUpdateJSON
-} from "./chunk-2JVXVTC5.mjs";
+} from "./chunk-OGAOUYV3.mjs";
 import {
-  __require
-} from "./chunk-ZFXKCRJC.mjs";
+  __require,
+  parseVersion,
+  unzipFile
+} from "./chunk-CMBFI77K.mjs";
 
 // src/index.ts
 import { resolve } from "node:path";
 import { existsSync as existsSync2, renameSync } from "node:fs";
-import Electron2 from "electron";
+import Electron from "electron";
 
 // src/updater/index.ts
 import { existsSync } from "node:fs";
@@ -51,11 +50,11 @@ var DownloadError = class extends Error {
 };
 
 // src/updater/defaultFunctions.ts
-import Electron from "electron";
+import { net } from "electron";
 var downloadJSONDefault = async (url, headers) => {
   await waitAppReady();
   return new Promise((resolve2, reject) => {
-    const request = Electron.net.request({
+    const request = net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -89,7 +88,7 @@ var downloadBufferDefault = async (url, headers, total, onDownloading) => {
   await waitAppReady();
   let current = 0;
   return new Promise((resolve2, reject) => {
-    const request = Electron.net.request({
+    const request = net.request({
       url,
       method: "GET",
       redirect: "follow"
@@ -150,9 +149,6 @@ var IncrementalUpdater = class {
   get productName() {
     return this.option.productName;
   }
-  set productName(name) {
-    this.option.productName = name;
-  }
   get receiveBeta() {
     return !!this.option.receiveBeta;
   }
@@ -161,14 +157,17 @@ var IncrementalUpdater = class {
   }
   constructor(option) {
     this.option = option;
+    if (!option.productName) {
+      this.option.productName = DEFAULT_APP_NAME;
+    }
     this.asarPath = getProductAsarPath(this.productName);
     this.gzipPath = `${this.asarPath}.gz`;
     this.tmpFilePath = `${this.asarPath}.tmp`;
   }
   async needUpdate(version, minVersion) {
     const compare = this.option.overrideFunctions?.compareVersion ?? compareVersionDefault;
-    const productVersion = getProductVersion(this.option.productName);
-    const entryVersion = getEntryVersion();
+    const productVersion = getAppVersion(this.option.productName);
+    const entryVersion = getElectronVersion();
     if (await compare(entryVersion, minVersion)) {
       throw new MinimumVersionError(entryVersion, minVersion);
     }
@@ -304,7 +303,7 @@ function initApp(appOptions) {
   } = hooks || {};
   function handleError(msg) {
     onStartError?.(new Error(msg));
-    Electron2.app.quit();
+    Electron.app.quit();
   }
   async function startup(updater) {
     try {
@@ -314,7 +313,7 @@ function initApp(appOptions) {
         await beforeDoUpdate?.(asarPath, updateAsarPath);
         renameSync(updateAsarPath, asarPath);
       }
-      const mainDir = Electron2.app.isPackaged ? asarPath : electronDevDistPath;
+      const mainDir = Electron.app.isPackaged ? asarPath : electronDevDistPath;
       const entry = resolve(__dirname, mainDir, mainPath);
       await beforeStart?.(entry);
       __require(entry)(updater);

package/dist/{updateJson.d.mts → updateJson-7e45d9e1.d.ts}

@@ -7,6 +7,5 @@ type UpdateInfo = {
 type UpdateJSON = UpdateInfo & {
     beta: UpdateInfo;
 };
-declare function isUpdateJSON(json: any): json is UpdateJSON;
 
-export { UpdateInfo, UpdateJSON, isUpdateJSON };
+export { UpdateJSON as U };