@shellraining/dsh-plugin-updates 0.0.0-stage → 0.1.0

package/lib/client.js

@@ -0,0 +1,2030 @@
+// Generated by `pnpm run build`; edit src/, not this file.
+window.__ModuleLoader__.load({
+  id: "@shellraining/dsh-plugin-updates",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js"(exports, module2) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js"(exports, module2) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js"(exports, module2) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports = module2.exports = {};
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var safeSrc = exports.safeSrc = [];
+    var t = exports.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name2, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name2, index, value);
+      t[name2] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js"(exports, module2) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module2.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js"(exports, module2) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js"(exports, module2) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var isPrereleaseIdentifier = (prerelease2, identifier) => {
+      const identifiers = identifier.split(".");
+      if (identifiers.length > prerelease2.length) {
+        return false;
+      }
+      for (let i = 0; i < identifiers.length; i++) {
+        if (compareIdentifiers(prerelease2[i], identifiers[i]) !== 0) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num = +id;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease2 = [identifier, base];
+              if (identifierBase === false) {
+                prerelease2 = [identifier];
+              }
+              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+                const prereleaseBase = this.prerelease[identifier.split(".").length];
+                if (isNaN(prereleaseBase)) {
+                  this.prerelease = prerelease2;
+                }
+              } else {
+                this.prerelease = prerelease2;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module2.exports = SemVer;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js"(exports, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module2.exports = compare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gt2 = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js"(exports, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module2.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js"(exports, module2) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease2 = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module2.exports = prerelease2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare2 = (a, b, loose) => compare(b, a, loose);
+    module2.exports = rcompare2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js"(exports, module2) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module2.exports = eq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module2.exports = neq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js"(exports, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js"(exports, module2) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt2 = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt2(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module2.exports = cmp;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js"(exports, module2) {
+    "use strict";
+    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js"(exports, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        range = range.replace(BUILDSTRIPRE, "");
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module2.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      src,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        if (invalidXRangeOrder(M, m, p)) {
+          return comp;
+        }
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js"(exports, module2) {
+    "use strict";
+    var Range = require_range();
+    var satisfies2 = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module2.exports = satisfies2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js"(exports, module2) {
+    "use strict";
+    var parse = require_parse();
+    var valid2 = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module2.exports = valid2;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js"(exports, module2) {
+    "use strict";
+    var Range = require_range();
+    var validRange2 = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = validRange2;
+  }
+});
+
+// src/client/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/locale.ts
+var LOCALE_NS = "dshPluginUpdates";
+var ZH = {
+  "tab": "\u66F4\u65B0",
+  "summary.loading": "\u6B63\u5728\u68C0\u67E5\u66F4\u65B0\u2026",
+  "summary.some": "{count} \u4E2A\u63D2\u4EF6\u53EF\u66F4\u65B0",
+  "summary.none": "\u6240\u6709 npm \u63D2\u4EF6\u90FD\u5DF2\u662F\u6700\u65B0\u7248\u672C",
+  "summary.empty": "\u6CA1\u6709\u4ECE npm \u5B89\u88C5\u7684\u63D2\u4EF6",
+  "summary.skipped": "{count} \u4E2A\u63D2\u4EF6\u4E0D\u662F\u4ECE npm \u5B89\u88C5\u7684\uFF0C\u672A\u68C0\u67E5",
+  "refresh": "\u68C0\u67E5\u66F4\u65B0",
+  "updateAll": "\u5168\u90E8\u66F4\u65B0",
+  "updateAllCount": "\u5168\u90E8\u66F4\u65B0\uFF08{count}\uFF09",
+  "updateLabel": "\u628A {name} \u66F4\u65B0\u5230 {version}",
+  "updating": "\u66F4\u65B0\u4E2D\u2026",
+  "update": "\u66F4\u65B0",
+  "updateTo": "\u66F4\u65B0\u5230 {version}",
+  "install": "\u5B89\u88C5",
+  "details": "\u8BE6\u60C5",
+  "loadFailed": "\u8BFB\u53D6\u63D2\u4EF6\u5217\u8868\u5931\u8D25\uFF1A{reason}",
+  "retry": "\u91CD\u8BD5",
+  "status.update": "\u53EF\u66F4\u65B0 {version}",
+  "status.latest": "\u5DF2\u662F\u6700\u65B0",
+  "status.checking": "\u68C0\u67E5\u4E2D",
+  "status.failed": "\u67E5\u8BE2\u5931\u8D25",
+  "version.current": "\u5F53\u524D {version}",
+  "version.arrow": "{from} \u2192 {to}",
+  "versions.title": "\u7248\u672C",
+  "versions.registry": "\u6765\u81EA {registry}",
+  "versions.showAll": "\u663E\u793A\u5168\u90E8 {count} \u4E2A\u7248\u672C",
+  "versions.empty": "\u6CA1\u6709\u53EF\u7528\u7684\u7248\u672C\u4FE1\u606F",
+  "versions.failed": "\u65E0\u6CD5\u4ECE npm \u8BFB\u53D6\u7248\u672C\uFF1A{reason}",
+  "tag.current": "\u5F53\u524D",
+  "tag.prerelease": "\u9884\u53D1\u5E03",
+  "tag.deprecated": "\u5DF2\u5E9F\u5F03",
+  "tag.incompatible": "\u4E0D\u517C\u5BB9",
+  "tag.fresh": "\u65B0\u53D1\u5E03",
+  "hint.fresh": "\u53D1\u5E03\u4E0D\u8DB3 24 \u5C0F\u65F6\uFF1Apnpm \u9ED8\u8BA4\u4E0D\u5B89\u88C5\u8FD9\u4E48\u65B0\u7684\u7248\u672C\uFF0C\u5B89\u88C5\u53EF\u80FD\u5931\u8D25",
+  "hint.incompatible": "\u4E0E\u5F53\u524D DSH \u7248\u672C\u4E0D\u517C\u5BB9\uFF0C\u5B89\u88C5\u4F1A\u88AB\u62D2\u7EDD",
+  "self.title": "\u672C\u63D2\u4EF6\u4E0D\u80FD\u5728\u9875\u9762\u91CC\u66F4\u65B0\u81EA\u5DF1",
+  "self.body": "\u5728\u9875\u9762\u91CC\u5378\u8F7D\u81EA\u5DF1\u4F1A\u8BA9\u8FD9\u4E2A\u754C\u9762\u4E00\u8D77\u6D88\u5931\u3002\u8BF7\u5148\u5B8C\u5168\u9000\u51FA DSH\uFF0C\u5728\u7EC8\u7AEF\u8FD0\u884C\u4E0B\u9762\u7684\u547D\u4EE4\uFF0C\u518D\u91CD\u65B0\u6253\u5F00\uFF1A",
+  "self.copy": "\u590D\u5236\u547D\u4EE4",
+  "self.copied": "\u5DF2\u590D\u5236",
+  "op.removing": "\u6B63\u5728\u5378\u8F7D {name} {from}\u2026",
+  "op.installing": "\u6B63\u5728\u5B89\u88C5 {name} {to}\u2026",
+  "op.restoring": "\u6B63\u5728\u6062\u590D {name} {to}\u2026",
+  "op.done": "{name} \u5DF2\u5207\u6362\u5230 {to}",
+  "op.restart": "{name} \u5DF2\u5207\u6362\u5230 {to}\uFF0C\u91CD\u542F DSH \u540E\u751F\u6548",
+  "op.failed": "{name} \u5B89\u88C5 {to} \u5931\u8D25\uFF1A{reason}",
+  "op.removeFailed": "{name} \u5378\u8F7D\u5931\u8D25\uFF0C\u6CA1\u6709\u505A\u4EFB\u4F55\u6539\u52A8\uFF1A{reason}",
+  "op.restore": "\u6062\u590D {from}",
+  "op.dismiss": "\u5173\u95ED",
+  "op.log": "\u65E5\u5FD7\uFF1A{path}"
+};
+var EN = {
+  "tab": "Updates",
+  "summary.loading": "Checking for updates\u2026",
+  "summary.some": "{count} plugin(s) can be updated",
+  "summary.none": "All npm plugins are up to date",
+  "summary.empty": "No plugins were installed from npm",
+  "summary.skipped": "{count} plugin(s) not installed from npm were skipped",
+  "refresh": "Check for updates",
+  "updateAll": "Update all",
+  "updateAllCount": "Update all ({count})",
+  "updateLabel": "Update {name} to {version}",
+  "updating": "Updating\u2026",
+  "update": "Update",
+  "updateTo": "Update to {version}",
+  "install": "Install",
+  "details": "Details",
+  "loadFailed": "Could not read the plugin list: {reason}",
+  "retry": "Retry",
+  "status.update": "Update {version}",
+  "status.latest": "Up to date",
+  "status.checking": "Checking",
+  "status.failed": "Check failed",
+  "version.current": "Current {version}",
+  "version.arrow": "{from} \u2192 {to}",
+  "versions.title": "Versions",
+  "versions.registry": "From {registry}",
+  "versions.showAll": "Show all {count} versions",
+  "versions.empty": "No version information",
+  "versions.failed": "Could not read versions from npm: {reason}",
+  "tag.current": "Current",
+  "tag.prerelease": "Prerelease",
+  "tag.deprecated": "Deprecated",
+  "tag.incompatible": "Incompatible",
+  "tag.fresh": "New",
+  "hint.fresh": "Published less than 24 hours ago: pnpm does not install versions this new by default, so installing may fail",
+  "hint.incompatible": "Not compatible with this DSH version; the installation would be refused",
+  "self.title": "This plugin cannot update itself from the page",
+  "self.body": "Uninstalling it from the page would unload this page too. Quit DSH completely, run this command in a terminal, then start DSH again:",
+  "self.copy": "Copy command",
+  "self.copied": "Copied",
+  "op.removing": "Uninstalling {name} {from}\u2026",
+  "op.installing": "Installing {name} {to}\u2026",
+  "op.restoring": "Restoring {name} {to}\u2026",
+  "op.done": "{name} is now at {to}",
+  "op.restart": "{name} is now at {to}; restart DSH to apply it",
+  "op.failed": "Could not install {name} {to}: {reason}",
+  "op.removeFailed": "Could not uninstall {name}; nothing changed: {reason}",
+  "op.restore": "Restore {from}",
+  "op.dismiss": "Dismiss",
+  "op.log": "Log: {path}"
+};
+
+// src/client/model.ts
+var import_gt = __toESM(require_gt(), 1);
+var import_prerelease = __toESM(require_prerelease(), 1);
+var import_rcompare = __toESM(require_rcompare(), 1);
+var import_satisfies = __toESM(require_satisfies(), 1);
+var import_valid = __toESM(require_valid(), 1);
+var import_valid2 = __toESM(require_valid2(), 1);
+var SELF = "@shellraining/dsh-plugin-updates";
+var DEFAULT_REGISTRY = "https://registry.npmjs.org/";
+var CACHE_MS = 10 * 6e4;
+var FRESH_MS = 24 * 60 * 6e4;
+function updateTarget(candidate, lookup) {
+  if (lookup?.status !== "ready") return void 0;
+  const best = lookup.versions.find((info) => info.compatible && !info.prerelease && !info.deprecated);
+  return best !== void 0 && (0, import_gt.default)(best.version, candidate.version) ? best.version : void 0;
+}
+function isBusy(operation) {
+  return operation?.phase === "removing" || operation?.phase === "installing";
+}
+function record(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function npmInstalled(bundle) {
+  const prefix = `${bundle.name}@`;
+  return bundle.installed && !bundle.official && bundle.availability === "profile" && bundle.removable && bundle.readOnlyReason === void 0 && (0, import_valid.default)(bundle.version ?? "") !== null && bundle.source?.startsWith(prefix) === true && (0, import_valid2.default)(bundle.source.slice(prefix.length)) !== null;
+}
+function compatibleWith(manifest, runtime) {
+  if (runtime === void 0) return true;
+  const fits = (range) => typeof range === "string" && range.trim() !== "" && (0, import_satisfies.default)(runtime, range, { includePrerelease: true });
+  const engines = record(manifest["engines"]);
+  if (Object.hasOwn(engines, "dsh")) return fits(engines["dsh"]);
+  return Object.entries(record(manifest["peerDependencies"])).filter(([name2]) => name2 === "@deepseek-ai/dsh" || name2.startsWith("@deepseek-ai/dsh-")).every(([, range]) => typeof range === "string" && range.startsWith("workspace:") ? true : fits(range));
+}
+function packumentUrl(registry, name2) {
+  return `${registry.endsWith("/") ? registry : `${registry}/`}${name2.replace("/", "%2f")}`;
+}
+function runtimeVersion(ctx) {
+  const modules = record(ctx.get("modules"));
+  const version = record(record(modules["manifest"])["release"])["version"];
+  return typeof version === "string" && (0, import_valid.default)(version) !== null ? version : void 0;
+}
+var UpdatesStore = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  state = { status: "idle", candidates: [], skipped: 0, lookups: {} };
+  listeners = /* @__PURE__ */ new Set();
+  generation = 0;
+  disposed = false;
+  registries;
+  exemptions = {};
+  getSnapshot = () => this.state;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  dispose() {
+    this.disposed = true;
+    this.listeners.clear();
+  }
+  patch(next) {
+    if (this.disposed) return;
+    this.state = { ...this.state, ...next };
+    for (const listener of [...this.listeners]) listener();
+  }
+  setLookup(name2, lookup) {
+    this.patch({ lookups: { ...this.state.lookups, [name2]: lookup } });
+  }
+  /** A page opened: read the list the first time, and again once a lookup is older than the cache. */
+  ensure = () => {
+    const now = Date.now();
+    const stale = Object.values(this.state.lookups).some((lookup) => lookup.status === "ready" && now - lookup.at > CACHE_MS);
+    if (this.state.status === "idle" || this.state.status === "ready" && stale) void this.load(false);
+  };
+  /** Re-read the list and every lookup. */
+  refresh = () => {
+    void this.load(true);
+  };
+  /** Re-read the list after a Host change; lookups stay cached. */
+  bundlesChanged = () => {
+    if (this.state.status !== "idle") void this.load(false);
+  };
+  async load(force) {
+    const generation = ++this.generation;
+    this.patch({ status: this.state.status === "ready" ? "ready" : "loading" });
+    const pm = this.ctx.remote.pluginManager;
+    if (force || this.registries === void 0) {
+      const [registries, exemptions] = await Promise.all([pm.registries(), pm.listVersionExemptions()]);
+      if (registries.ok) {
+        const first = registries.value.registry ?? registries.value.resolved ?? DEFAULT_REGISTRY;
+        this.registries = [.../* @__PURE__ */ new Set([first, ...registries.value.fallbackRegistries])];
+      }
+      if (exemptions.ok) this.exemptions = exemptions.value.exemptions;
+    }
+    const listed = await pm.listBundles();
+    if (generation !== this.generation) return;
+    if (!listed.ok) {
+      this.patch({ status: "error", error: listed.error.message });
+      return;
+    }
+    const resolve = (text) => text === void 0 ? void 0 : this.ctx.locale.resolveText(text);
+    const npm = listed.value.filter(npmInstalled);
+    const candidates = npm.map((bundle) => {
+      const icon = bundle.meta?.icon;
+      return {
+        name: bundle.name,
+        title: resolve(bundle.meta?.title) ?? bundle.name,
+        version: bundle.version ?? "",
+        enabled: bundle.enabled,
+        ...icon === void 0 ? {} : { icon }
+      };
+    }).sort((a, b) => a.title.localeCompare(b.title));
+    const others = listed.value.filter((bundle) => bundle.installed && !bundle.official && bundle.availability === "profile");
+    this.patch({ status: "ready", candidates, skipped: others.length - npm.length });
+    const now = Date.now();
+    for (const candidate of candidates) {
+      const lookup = this.state.lookups[candidate.name];
+      const stale = lookup === void 0 || lookup.status === "error" || lookup.status === "ready" && now - lookup.at > CACHE_MS;
+      if (force || stale) void this.lookup(candidate.name);
+    }
+  }
+  async lookup(name2) {
+    this.setLookup(name2, { status: "loading" });
+    const runtime = runtimeVersion(this.ctx);
+    let reason = "";
+    for (const registry of this.registries ?? [DEFAULT_REGISTRY]) {
+      try {
+        const response = await fetch(packumentUrl(registry, name2), { headers: { accept: "application/json" }, credentials: "omit" });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const body = record(await response.json());
+        const times = record(body["time"]);
+        const now = Date.now();
+        const versions = Object.entries(record(body["versions"])).filter(([version]) => (0, import_valid.default)(version) !== null).map(([version, manifest]) => {
+          const fields = record(manifest);
+          const stamp = typeof times[version] === "string" ? Date.parse(times[version]) : Number.NaN;
+          const exempted = runtime !== void 0 && this.exemptions[`${name2}@${version}`]?.includes(runtime) === true;
+          return {
+            version,
+            ...Number.isNaN(stamp) ? {} : { published: stamp },
+            deprecated: typeof fields["deprecated"] === "string",
+            prerelease: (0, import_prerelease.default)(version) !== null,
+            compatible: exempted || compatibleWith(fields, runtime),
+            fresh: !Number.isNaN(stamp) && now - stamp < FRESH_MS
+          };
+        }).sort((a, b) => (0, import_rcompare.default)(a.version, b.version));
+        const latest = record(body["dist-tags"])["latest"];
+        this.setLookup(name2, { status: "ready", registry, versions, at: now, ...typeof latest === "string" ? { latest } : {} });
+        return;
+      } catch (error) {
+        reason = `${new URL(registry).host}: ${errorText(error)}`;
+      }
+    }
+    this.setLookup(name2, { status: "error", reason });
+  }
+  /** Switch one plugin to `version`: uninstall it, then install that exact version with its enabled state. */
+  install = async (name2, version) => {
+    const candidate = this.state.candidates.find((item) => item.name === name2);
+    if (candidate === void 0 || name2 === SELF || isBusy(this.state.operation)) return false;
+    return this.run({ name: name2, from: candidate.version, to: version, enabled: candidate.enabled, restoring: false }, true);
+  };
+  /** Put back the version a failed switch removed; the plugin is no longer installed, so only install. */
+  restore = async () => {
+    const failed = this.state.operation;
+    if (failed?.phase !== "failed" || failed.restoring) return;
+    await this.run({ name: failed.name, from: failed.to, to: failed.from, enabled: failed.enabled, restoring: true }, false);
+  };
+  /** The outcome toast finished; the banner in the tab keeps the result. */
+  toastDone = () => {
+    const operation = this.state.operation;
+    if (operation?.toast !== void 0) {
+      const { toast: _toast, ...rest } = operation;
+      this.patch({ operation: rest });
+    }
+  };
+  dismiss = () => {
+    if (!isBusy(this.state.operation)) this.patch({ operation: void 0 });
+  };
+  /** Update every plugin with a newer version, one at a time; stops at the first failure. */
+  updateAll = async () => {
+    for (const candidate of this.state.candidates) {
+      const target = updateTarget(candidate, this.state.lookups[candidate.name]);
+      if (target === void 0 || candidate.name === SELF) continue;
+      if (!await this.install(candidate.name, target)) return;
+    }
+  };
+  async run(base, remove) {
+    const pm = this.ctx.remote.pluginManager;
+    const fail = (phase, result) => {
+      const value = result.ok ? result.value : void 0;
+      const output = value?.packageResult?.output.trim();
+      const logPath = value?.packageResult?.logPath;
+      const reason = result.ok ? value?.error?.diagnostic?.split("\n")[0] ?? value?.error?.code ?? value?.application ?? "" : result.error.message;
+      this.patch({ operation: { ...base, phase, reason, toast: Date.now(), ...output ? { output } : {}, ...logPath ? { logPath } : {} } });
+      return false;
+    };
+    if (remove) {
+      this.patch({ operation: { ...base, phase: "removing" } });
+      const removed = await pm.removeBundle(base.name);
+      const stopProfile = removed.ok && removed.value.error?.code === "stop-profile";
+      if (!stopProfile && (!removed.ok || removed.value.application === "failed" || removed.value.application === "cancelled")) {
+        return fail("remove-failed", removed);
+      }
+    }
+    this.patch({ operation: { ...base, phase: "installing" } });
+    const installed = await pm.installBundle(`${base.name}@${base.to}`, {
+      enabled: base.enabled,
+      saveExact: true,
+      requestId: `${SELF}:${Date.now()}`
+    });
+    if (!installed.ok || installed.value.application === "failed" || installed.value.application === "cancelled") {
+      return fail("failed", installed);
+    }
+    const to = installed.value.version ?? base.to;
+    this.patch({ operation: { ...base, to, toast: Date.now(), phase: installed.value.application === "restart-required" ? "restart" : "done" } });
+    return true;
+  }
+};
+
+// src/client/styles.ts
+var STYLE_ID = "@shellraining/dsh-plugin-updates";
+var CSS = `
+.dpu-tab, .dpu-section { display: flex; flex-direction: column; gap: 12px; min-width: 0; color: var(--dsw-alias-label-primary); }
+.dpu-head { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; min-height: 28px; }
+.dpu-summary { flex: 1; min-width: 0; color: var(--dsw-alias-label-secondary); font-size: 13px; line-height: 20px; }
+.dpu-caption { color: var(--dsw-alias-label-caption); font-size: 12px; line-height: 18px; }
+.dpu-title { margin: 0; font-size: 14px; font-weight: 500; line-height: 20px; }
+.dpu-list { display: flex; flex-direction: column; margin: 0; padding: 0; list-style: none; }
+.dpu-card { display: flex; align-items: center; gap: 14px; min-width: 0; margin: 0 -8px; padding: 8px; border-radius: var(--dsw-radius-xl); }
+.dpu-card:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.dpu-icon { flex: none; display: inline-flex; align-items: center; justify-content: center; width: 40px; height: 40px; overflow: hidden; border: .5px solid var(--dsw-alias-border-l3); border-radius: var(--dsw-radius-lg); color: var(--dsw-alias-label-secondary); }
+.dpu-icon img { width: 100%; height: 100%; object-fit: cover; }
+.dpu-main { flex: 1; display: flex; flex-direction: column; gap: 2px; min-width: 0; }
+.dpu-name-row { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; min-width: 0; }
+.dpu-name { min-width: 0; padding: 0; overflow: hidden; border: 0; background: none; color: inherit; font: inherit; font-size: 14px; font-weight: 500; line-height: 20px; text-align: left; text-overflow: ellipsis; white-space: nowrap; cursor: pointer; }
+.dpu-name:hover { text-decoration: underline; }
+.dpu-name:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 2px; }
+.dpu-meta { color: var(--dsw-alias-label-tertiary); font-size: 13px; line-height: 18px; font-variant-numeric: tabular-nums; }
+.dpu-end { flex: none; display: inline-flex; align-items: center; gap: 8px; }
+.dpu-mono { font-family: var(--ds-font-family-code); font-variant-numeric: tabular-nums; }
+.dpu-rows { display: flex; flex-direction: column; margin: 0; padding: 0; list-style: none; border-top: .5px solid var(--dsw-alias-border-l2); }
+.dpu-row { display: flex; align-items: center; gap: 8px; min-height: 36px; padding: 2px 0; border-bottom: .5px solid var(--dsw-alias-border-l2); }
+.dpu-row-version { min-width: 96px; font-size: 13px; }
+.dpu-row-tags { flex: 1; display: flex; flex-wrap: wrap; align-items: center; gap: 6px; min-width: 0; }
+.dpu-banner { display: flex; flex-direction: column; gap: 8px; padding: 10px 12px; border: .5px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-md); background: var(--dsw-alias-bg-layer-1); font-size: 13px; line-height: 20px; }
+.dpu-banner[data-tone="error"] { color: var(--dsw-alias-state-error-primary); background: var(--dsw-alias-interactive-bg-hover-danger, var(--dsw-alias-bg-layer-1)); }
+.dpu-banner-row { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; }
+.dpu-banner-row > span { flex: 1; min-width: 0; overflow-wrap: anywhere; }
+.dpu-pre { max-height: 160px; margin: 0; padding: 8px 10px; overflow: auto; border-radius: var(--dsw-radius-md); background: var(--dsw-alias-markdown-code-block); color: var(--dsw-alias-label-secondary); font: 400 12px / 1.6 var(--ds-font-family-code); white-space: pre-wrap; overflow-wrap: anywhere; user-select: text; }
+.dpu-command { flex: 1; min-width: 0; }
+.dpu-error { color: var(--dsw-alias-state-error-primary); font-size: 13px; line-height: 20px; overflow-wrap: anywhere; }
+@media (forced-colors: active) { .dpu-banner { border-color: CanvasText; } }
+`;
+function installStyle(document2) {
+  const node = document2.createElement("style");
+  node.dataset.plugin = STYLE_ID;
+  node.textContent = CSS;
+  document2.head.append(node);
+  return () => node.remove();
+}
+
+// src/client/view.tsx
+var import_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+var import_dsh_client_ui_primitives2 = require("@deepseek-ai/dsh-client-ui-primitives");
+var import_react = require("react");
+var import_react_dom = require("react-dom");
+
+// src/client/anchors.ts
+var GROUP = 'section[data-plugin-group="bundles"]';
+var MOUNT = "data-plugin-updates-mount";
+var NO_ANCHORS = { cards: /* @__PURE__ */ new Map() };
+function mountIn(parent, key, first) {
+  for (const child of parent.children) {
+    if (child instanceof HTMLElement && child.getAttribute(MOUNT) === key) return child;
+  }
+  const node = parent.ownerDocument.createElement("span");
+  node.setAttribute(MOUNT, key);
+  node.style.display = "contents";
+  if (first) parent.prepend(node);
+  else parent.append(node);
+  return node;
+}
+function scan(document2) {
+  const group = document2.querySelector(GROUP);
+  if (group === null) return NO_ANCHORS;
+  const row = group.firstElementChild;
+  const head = row?.querySelector(":scope > h3") ? mountIn(row, "head", false) : void 0;
+  const cards = /* @__PURE__ */ new Map();
+  for (const card of group.querySelectorAll("li[data-plugin-package]")) {
+    const name2 = card.getAttribute("data-plugin-package");
+    const end = card.querySelector('[role="switch"]')?.parentElement;
+    if (name2 && end) cards.set(name2, mountIn(end, "card", true));
+  }
+  return { ...head === void 0 ? {} : { head }, cards };
+}
+function same(a, b) {
+  if (a.head !== b.head || a.cards.size !== b.cards.size) return false;
+  for (const [name2, node] of a.cards) if (b.cards.get(name2) !== node) return false;
+  return true;
+}
+function watchAnchors(document2, onChange) {
+  const view = document2.defaultView;
+  if (view === null) return () => {
+  };
+  let current = NO_ANCHORS;
+  let frame = 0;
+  const run = () => {
+    frame = 0;
+    const next = scan(document2);
+    if (same(current, next)) return;
+    current = next;
+    onChange(next);
+  };
+  const observer = new view.MutationObserver(() => {
+    if (frame === 0) frame = view.requestAnimationFrame(run);
+  });
+  observer.observe(document2.body, { childList: true, subtree: true });
+  run();
+  return () => {
+    observer.disconnect();
+    if (frame !== 0) view.cancelAnimationFrame(frame);
+    for (const node of document2.querySelectorAll(`[${MOUNT}]`)) node.remove();
+  };
+}
+
+// src/client/view.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var VISIBLE_VERSIONS = 12;
+function selfCommand(version) {
+  const profile = document.documentElement.dataset["platform"] === void 0 ? "web" : "desktop";
+  return `dsh plugin --profile ${profile} add ${SELF}@${version} --save-exact`;
+}
+function dateText(stamp) {
+  return stamp === void 0 ? "" : new Date(stamp).toLocaleDateString();
+}
+function Artwork({ src }) {
+  const [broken, setBroken] = (0, import_react.useState)(false);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-icon", "aria-hidden": "true", children: src === void 0 || broken ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.PluginArtworkDefault, { size: 28 }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("img", { src, alt: "", onError: () => setBroken(true) }) });
+}
+function StatusTag({ t, candidate, lookup }) {
+  if (lookup === void 0 || lookup.status === "loading") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "quiet", children: t("status.checking") });
+  if (lookup.status === "error") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "warning", children: t("status.failed") });
+  const target = updateTarget(candidate, lookup);
+  return target === void 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "quiet", children: t("status.latest") }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "info", children: t("status.update", { version: target }) });
+}
+function SelfNotice({ t, version }) {
+  const [copied, setCopied] = (0, import_react.useState)(false);
+  const command = selfCommand(version);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-banner", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: t("self.title") }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: t("self.body") }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-banner-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { className: "dpu-pre dpu-command", children: command }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", onClick: () => {
+        void (0, import_dsh_client_ui_primitives.writeClipboard)(command).then(setCopied);
+      }, children: copied ? t("self.copied") : t("self.copy") })
+    ] })
+  ] });
+}
+function operationText(t, operation) {
+  const params = { name: operation.name, from: operation.from, to: operation.to, reason: operation.reason ?? "" };
+  switch (operation.phase) {
+    case "removing":
+      return t("op.removing", params);
+    case "installing":
+      return t(operation.restoring ? "op.restoring" : "op.installing", params);
+    case "done":
+      return t("op.done", params);
+    case "restart":
+      return t("op.restart", params);
+    case "failed":
+      return t("op.failed", params);
+    case "remove-failed":
+      return t("op.removeFailed", params);
+  }
+}
+function OperationToast({ t, useUpdates, actions }) {
+  const operation = useUpdates((state) => state.operation);
+  if (operation?.toast === void 0) return null;
+  const failed = operation.phase === "failed" || operation.phase === "remove-failed";
+  const restorable = operation.phase === "failed" && !operation.restoring;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_dsh_client_ui_primitives.Toast,
+    {
+      text: operationText(t, operation),
+      ...failed ? { icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives2.IconWarningOutlineRegular, {}) } : { tone: "success" },
+      holdMs: failed ? 8e3 : 4e3,
+      ...restorable ? { actions: [{ label: t("op.restore", { from: operation.from }), onClick: () => {
+        void actions.restore();
+      } }] } : {},
+      onDone: actions.toastDone
+    },
+    operation.toast
+  );
+}
+function OperationBanner({ t, operation, actions }) {
+  const params = { from: operation.from };
+  const busy = isBusy(operation);
+  const failed = operation.phase === "failed" || operation.phase === "remove-failed";
+  const text = operationText(t, operation);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-banner", role: failed ? "alert" : "status", ...failed ? { "data-tone": "error" } : {}, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-banner-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: text }),
+      operation.phase === "failed" && !operation.restoring ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", onClick: () => {
+        void actions.restore();
+      }, children: t("op.restore", params) }) : null,
+      busy ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "ghost", onClick: actions.dismiss, children: t("op.dismiss") })
+    ] }),
+    failed && operation.output !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { className: "dpu-pre", children: operation.output }) : null,
+    failed && operation.logPath !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-caption", children: t("op.log", { path: operation.logPath }) }) : null
+  ] });
+}
+function UpdatesTab({ t, useUpdates, actions, openPackage }) {
+  const state = useUpdates((snapshot) => snapshot);
+  (0, import_react.useEffect)(() => {
+    actions.ensure();
+  }, [actions]);
+  const busy = isBusy(state.operation);
+  const lookups = Object.values(state.lookups);
+  const checking = state.status === "loading" || lookups.some((lookup) => lookup.status === "loading");
+  const outdated = state.candidates.filter((item) => updateTarget(item, state.lookups[item.name]) !== void 0);
+  const pending = outdated.filter((item) => item.name !== SELF);
+  const self = outdated.find((item) => item.name === SELF);
+  const selfTarget = self === void 0 ? void 0 : updateTarget(self, state.lookups[SELF]);
+  let summary;
+  if (state.status === "idle" || state.status === "loading" && state.candidates.length === 0) summary = t("summary.loading");
+  else if (state.candidates.length === 0) summary = t("summary.empty");
+  else if (outdated.length > 0) summary = t("summary.some", { count: outdated.length });
+  else summary = checking ? t("summary.loading") : t("summary.none");
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "dpu-tab", "aria-busy": checking, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-head", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-summary", role: "status", children: summary }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives2.IconRefreshOutlineRegular, { size: 13 }), disabled: checking || busy, onClick: actions.refresh, children: t("refresh") }),
+      pending.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "primary", disabled: busy, onClick: () => {
+        void actions.updateAll();
+      }, children: t("updateAll") }) : null
+    ] }),
+    state.operation === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OperationBanner, { t, operation: state.operation, actions }),
+    state.status === "error" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "dpu-banner", "data-tone": "error", role: "alert", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-banner-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: t("loadFailed", { reason: state.error ?? "" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", onClick: actions.refresh, children: t("retry") })
+    ] }) }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { className: "dpu-list", children: state.candidates.map((candidate) => {
+      const lookup = state.lookups[candidate.name];
+      const target = updateTarget(candidate, lookup);
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { className: "dpu-card", "data-plugin-updates-package": candidate.name, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Artwork, { src: candidate.icon }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-main", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-name-row", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dpu-name", title: candidate.name, onClick: () => openPackage(candidate.name), children: candidate.title }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StatusTag, { t, candidate, lookup })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "dpu-meta", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-mono", children: target === void 0 ? candidate.version : t("version.arrow", { from: candidate.version, to: target }) }),
+            lookup?.status === "error" ? ` \xB7 ${lookup.reason}` : ""
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-end", children: [
+          target !== void 0 && candidate.name !== SELF ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives2.IconDownloadOutlineRegular, { size: 13 }), disabled: busy, onClick: () => {
+            void actions.install(candidate.name, target);
+          }, children: t("update") }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "ghost", onClick: () => openPackage(candidate.name), children: t("details") })
+        ] })
+      ] }, candidate.name);
+    }) }),
+    state.skipped > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-caption", children: t("summary.skipped", { count: state.skipped }) }) : null,
+    selfTarget === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelfNotice, { t, version: selfTarget })
+  ] });
+}
+function useSubject({ subject, useUpdates, actions }) {
+  const name2 = subject.kind === "bundle" ? subject.pkg.name : void 0;
+  const candidate = useUpdates((state) => state.candidates.find((item) => item.name === name2));
+  const lookup = useUpdates((state) => name2 === void 0 ? void 0 : state.lookups[name2]);
+  const operation = useUpdates((state) => state.operation);
+  (0, import_react.useEffect)(() => {
+    if (name2 !== void 0) actions.ensure();
+  }, [actions, name2]);
+  return candidate === void 0 ? void 0 : { candidate, lookup, operation };
+}
+function DetailBadge(props) {
+  const found = useSubject(props);
+  const target = found === void 0 ? void 0 : updateTarget(found.candidate, found.lookup);
+  return target === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "info", children: props.t("status.update", { version: target }) });
+}
+function DetailAction(props) {
+  const found = useSubject(props);
+  const target = found === void 0 ? void 0 : updateTarget(found.candidate, found.lookup);
+  if (found === void 0 || target === void 0 || found.candidate.name === SELF) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "primary", icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives2.IconDownloadOutlineRegular, { size: 13 }), disabled: isBusy(found.operation), onClick: () => {
+    void props.actions.install(found.candidate.name, target);
+  }, children: props.t("updateTo", { version: target }) });
+}
+function VersionRow({ t, info, current, disabled, onInstall }) {
+  const hint = !info.compatible ? t("hint.incompatible") : info.fresh ? t("hint.fresh") : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { className: "dpu-row", ...hint === void 0 ? {} : { title: hint }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-row-version dpu-mono", children: info.version }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "dpu-row-tags", children: [
+      current ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "success", children: t("tag.current") }) : null,
+      info.prerelease ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "neutral", children: t("tag.prerelease") }) : null,
+      info.deprecated ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "warning", children: t("tag.deprecated") }) : null,
+      !info.compatible ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "danger", children: t("tag.incompatible") }) : null,
+      info.fresh ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Tag, { tone: "warning", children: t("tag.fresh") }) : null
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-caption", children: dateText(info.published) }),
+    current || onInstall === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "ghost", disabled: disabled || !info.compatible, onClick: onInstall, children: t("install") })
+  ] });
+}
+function DetailSection(props) {
+  const found = useSubject(props);
+  const [all, setAll] = (0, import_react.useState)(false);
+  if (found === void 0) return null;
+  const { t, actions } = props;
+  const { candidate, lookup, operation } = found;
+  const self = candidate.name === SELF;
+  const target = updateTarget(candidate, lookup);
+  let body;
+  if (lookup === void 0 || lookup.status === "loading") body = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-caption", children: t("summary.loading") });
+  else if (lookup.status === "error") body = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-error", children: t("versions.failed", { reason: lookup.reason }) });
+  else if (lookup.versions.length === 0) body = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dpu-caption", children: t("versions.empty") });
+  else {
+    const shown = all ? lookup.versions : lookup.versions.slice(0, VISIBLE_VERSIONS);
+    body = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { className: "dpu-rows", children: shown.map((info) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        VersionRow,
+        {
+          t,
+          info,
+          current: info.version === candidate.version,
+          disabled: isBusy(operation),
+          onInstall: self ? void 0 : () => {
+            void actions.install(candidate.name, info.version);
+          }
+        },
+        info.version
+      )) }),
+      shown.length < lookup.versions.length ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "ghost", onClick: () => setAll(true), children: t("versions.showAll", { count: lookup.versions.length }) }) }) : null
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "dpu-section", "data-plugin-updates-versions": candidate.name, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dpu-head", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { className: "dpu-title", children: t("versions.title") }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "dpu-summary", children: [
+        t("version.current", { version: candidate.version }),
+        lookup?.status === "ready" ? ` \xB7 ${t("versions.registry", { registry: new URL(lookup.registry).host })}` : ""
+      ] })
+    ] }),
+    operation?.name === candidate.name ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OperationBanner, { t, operation, actions }) : null,
+    self && target !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SelfNotice, { t, version: target }) : null,
+    body
+  ] });
+}
+function ListControls({ t, useUpdates, actions }) {
+  const [anchors, setAnchors] = (0, import_react.useState)(NO_ANCHORS);
+  (0, import_react.useEffect)(() => watchAnchors(document, setAnchors), []);
+  const visible = anchors.head !== void 0 || anchors.cards.size > 0;
+  (0, import_react.useEffect)(() => {
+    if (visible) actions.ensure();
+  }, [actions, visible]);
+  const candidates = useUpdates((state) => state.candidates);
+  const lookups = useUpdates((state) => state.lookups);
+  const operation = useUpdates((state) => state.operation);
+  const busy = isBusy(operation);
+  const targets = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const target = updateTarget(candidate, lookups[candidate.name]);
+    if (target !== void 0 && candidate.name !== SELF) targets.set(candidate.name, target);
+  }
+  const portals = [];
+  if (anchors.head !== void 0 && targets.size > 0) {
+    portals.push((0, import_react_dom.createPortal)(
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives2.IconDownloadOutlineRegular, { size: 13 }), disabled: busy, onClick: () => {
+        void actions.updateAll();
+      }, children: t("updateAllCount", { count: targets.size }) }),
+      anchors.head,
+      "head"
+    ));
+  }
+  for (const [name2, node] of anchors.cards) {
+    const target = targets.get(name2);
+    if (target === void 0) continue;
+    const running = busy && operation?.name === name2;
+    portals.push((0, import_react_dom.createPortal)(
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { size: "sm", variant: "outline", disabled: busy, "aria-label": t("updateLabel", { name: name2, version: target }), onClick: () => {
+        void actions.install(name2, target);
+      }, children: running ? t("updating") : t("updateTo", { version: target }) }),
+      node,
+      name2
+    ));
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: portals });
+}
+
+// src/client/index.tsx
+var name = "@shellraining/dsh-plugin-updates";
+var inject = ["slots", "locale", "remote", "remote.pluginManager"];
+function apply(ctx) {
+  ctx.effect(() => ctx.locale.register(LOCALE_NS, { zh: ZH, en: EN }), `${name}: copy`);
+  ctx.effect(() => installStyle(document), `${name}: stylesheet`);
+  const store = new UpdatesStore(ctx);
+  ctx.effect(() => () => store.dispose(), `${name}: store`);
+  ctx.effect(() => {
+    const offs = [ctx.remote.$on("plugin-manager/changed", store.bundlesChanged), ctx.on("connection/reset", store.bundlesChanged)];
+    return () => {
+      for (const off of offs) off();
+    };
+  }, `${name}: host invalidations`);
+  const t = ctx.locale.bind(LOCALE_NS);
+  const face = {
+    hooks: { updates: store },
+    actions: {
+      ensure: store.ensure,
+      refresh: store.refresh,
+      install: store.install,
+      updateAll: store.updateAll,
+      restore: store.restore,
+      dismiss: store.dismiss,
+      toastDone: store.toastDone
+    }
+  };
+  ctx.slots.inject("plugins.tab", () => ctx.slots.register({
+    name: "plugins.tab",
+    id: "updates",
+    order: 10,
+    label: () => t("tab"),
+    locale: LOCALE_NS,
+    inject: () => face
+  }, UpdatesTab));
+  ctx.slots.inject("shell.overlay", () => ctx.slots.register({
+    name: "shell.overlay",
+    id: "plugin-updates.toast",
+    locale: LOCALE_NS,
+    inject: () => face
+  }, OperationToast));
+  ctx.slots.inject("shell.overlay", () => ctx.slots.register({
+    name: "shell.overlay",
+    id: "plugin-updates.list",
+    locale: LOCALE_NS,
+    inject: () => face
+  }, ListControls));
+  for (const [slot, component] of [
+    ["plugins.detail.badge", DetailBadge],
+    ["plugins.detail.actions", DetailAction],
+    ["plugins.detail.section", DetailSection]
+  ]) {
+    ctx.slots.inject(slot, () => ctx.slots.register({
+      name: slot,
+      id: "plugin-updates",
+      locale: LOCALE_NS,
+      inject: () => face
+    }, component));
+  }
+}
+
+    return module.exports;
+  },
+});