@storm-software/git-tools 2.104.42 → 2.104.44

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. package/README.md +1 -1
  2. package/bin/{chunk-BAUD34AK.js → chunk-3M5VVOEZ.js} +2 -2
  3. package/bin/{chunk-LJBGJPPU.cjs → chunk-4QPWQKY3.cjs} +32 -32
  4. package/bin/{chunk-3YCY7WOJ.cjs → chunk-4YIK3VPZ.cjs} +153 -153
  5. package/bin/{chunk-TINWNS4N.js → chunk-6GVZLBQN.js} +1 -1
  6. package/bin/{chunk-UNNNRATD.js → chunk-6NRXZ6QR.js} +1 -1
  7. package/bin/{chunk-UNBZYSZQ.cjs → chunk-ADTYFYQS.cjs} +138 -138
  8. package/bin/{chunk-H6XAJ45L.js → chunk-COHNBYUO.js} +2 -2
  9. package/bin/{chunk-4YADVZY3.js → chunk-DVEFA4T3.js} +2 -2
  10. package/bin/{chunk-SLKOUTYF.js → chunk-G3URB66P.js} +1 -1
  11. package/bin/{chunk-RHUTEEJZ.cjs → chunk-GHBDMGTX.cjs} +40 -40
  12. package/bin/{chunk-RIRBANM7.cjs → chunk-HFUQXREM.cjs} +3 -3
  13. package/bin/{chunk-DKE6RUCO.js → chunk-IRMYUCHS.js} +2 -2
  14. package/bin/{chunk-PDS3VIYI.js → chunk-NPRSXWA2.js} +10 -10
  15. package/bin/{chunk-PKUTAHKY.js → chunk-O6CNNZEF.js} +1 -1
  16. package/bin/{chunk-AS2SJCPQ.cjs → chunk-PEQKS3P6.cjs} +2228 -2228
  17. package/bin/{chunk-PMS5GJKU.cjs → chunk-PSFME3R5.cjs} +2 -2
  18. package/bin/{chunk-OC2DNWXQ.cjs → chunk-PWYCQTR6.cjs} +44 -44
  19. package/bin/{chunk-QX54YOLJ.cjs → chunk-QH2YKC7K.cjs} +4 -4
  20. package/bin/{chunk-6LCOCP5R.js → chunk-QM7PF55H.js} +2 -2
  21. package/bin/{chunk-76QSQFB2.cjs → chunk-QNPO2V3D.cjs} +5 -5
  22. package/bin/{chunk-ALVTBP6X.js → chunk-R7DMKRZJ.js} +2 -2
  23. package/bin/{chunk-RAZSMU2Y.cjs → chunk-TELC6KPD.cjs} +11 -11
  24. package/bin/{chunk-PJBUPPE5.js → chunk-ULT2OA4X.js} +2 -2
  25. package/bin/{chunk-4VYGXQ63.cjs → chunk-WKI5Y5T6.cjs} +388 -388
  26. package/bin/{dist-FFCMM5V4.cjs → dist-6ZEGWWVT.cjs} +1038 -1038
  27. package/bin/{dist-EGDS6DHF.js → dist-HW2G5BOV.js} +2 -2
  28. package/bin/{dist-RGSEOYRN.js → dist-VPU5OFWR.js} +8 -8
  29. package/bin/{dist-DA6ER5UH.cjs → dist-ZOQMIT2F.cjs} +8 -8
  30. package/bin/{esm-APEBY4LU.cjs → esm-ARXRUJHA.cjs} +46 -46
  31. package/bin/{esm-WJBKFFXO.js → esm-GQFWT3ED.js} +1 -1
  32. package/bin/git.cjs +4584 -6530
  33. package/bin/git.js +51 -2092
  34. package/bin/json5-VE2C3QLL.js +10 -0
  35. package/bin/json5-W22CYLPA.cjs +10 -0
  36. package/bin/{jsonc-UXZUXE5A.js → jsonc-5XS7J23X.js} +3 -3
  37. package/bin/jsonc-QQ2GWIUH.cjs +15 -0
  38. package/bin/{multipart-parser-57V34SDK.cjs → multipart-parser-CXO4FRZU.cjs} +11 -11
  39. package/bin/{multipart-parser-JM5SRUGB.js → multipart-parser-I45X3EY3.js} +2 -2
  40. package/bin/post-checkout.cjs +22 -22
  41. package/bin/post-checkout.js +10 -10
  42. package/bin/post-commit.cjs +22 -22
  43. package/bin/post-commit.js +10 -10
  44. package/bin/post-merge.cjs +22 -22
  45. package/bin/post-merge.js +10 -10
  46. package/bin/pre-commit.cjs +20 -20
  47. package/bin/pre-commit.js +9 -9
  48. package/bin/pre-install.cjs +19 -19
  49. package/bin/pre-install.js +9 -9
  50. package/bin/pre-push.cjs +27 -27
  51. package/bin/pre-push.js +10 -10
  52. package/bin/prepare.cjs +17 -17
  53. package/bin/prepare.js +9 -9
  54. package/bin/toml-327DP3E3.js +10 -0
  55. package/bin/toml-YGIRPOJX.cjs +10 -0
  56. package/bin/{utils-AT5XGAT4.cjs → utils-6GPBIZRI.cjs} +10 -10
  57. package/bin/{utils-YJUYC3LM.js → utils-77IDU6XM.js} +2 -2
  58. package/bin/version-warning.cjs +15 -15
  59. package/bin/version-warning.js +9 -9
  60. package/bin/yaml-45GLSIVG.js +10 -0
  61. package/bin/yaml-4EWLBYLX.cjs +10 -0
  62. package/package.json +1 -1
  63. package/bin/json5-XU2RUFJQ.js +0 -10
  64. package/bin/json5-YV5I4DH3.cjs +0 -10
  65. package/bin/jsonc-6LA7Y6SO.cjs +0 -15
  66. package/bin/toml-4VVY5LRD.js +0 -10
  67. package/bin/toml-DQ4EZ2G5.cjs +0 -10
  68. package/bin/yaml-3BWWOPH3.js +0 -10
  69. package/bin/yaml-V6LUJIDL.cjs +0 -10
package/bin/git.js CHANGED
@@ -1,7 +1,7 @@
1
1
  #!/usr/bin/env node
2
2
  import {
3
3
  run
4
- } from "./chunk-TINWNS4N.js";
4
+ } from "./chunk-6GVZLBQN.js";
5
5
  import {
6
6
  exitWithError,
7
7
  exitWithSuccess,
@@ -21,15 +21,15 @@ import {
21
21
  writeInfo,
22
22
  writeSuccess,
23
23
  writeWarning
24
- } from "./chunk-PDS3VIYI.js";
24
+ } from "./chunk-NPRSXWA2.js";
25
25
  import {
26
26
  defu
27
- } from "./chunk-PJBUPPE5.js";
28
- import "./chunk-H6XAJ45L.js";
29
- import "./chunk-DKE6RUCO.js";
30
- import "./chunk-6LCOCP5R.js";
31
- import "./chunk-ALVTBP6X.js";
32
- import "./chunk-UNNNRATD.js";
27
+ } from "./chunk-ULT2OA4X.js";
28
+ import "./chunk-COHNBYUO.js";
29
+ import "./chunk-IRMYUCHS.js";
30
+ import "./chunk-QM7PF55H.js";
31
+ import "./chunk-R7DMKRZJ.js";
32
+ import "./chunk-6NRXZ6QR.js";
33
33
  import {
34
34
  __commonJS,
35
35
  __esm,
@@ -38,7 +38,7 @@ import {
38
38
  __require,
39
39
  __toESM,
40
40
  init_esm_shims
41
- } from "./chunk-BAUD34AK.js";
41
+ } from "./chunk-3M5VVOEZ.js";
42
42
 
43
43
  // ../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/error.js
44
44
  var require_error = __commonJS({
@@ -57677,2047 +57677,6 @@ var require_versions = __commonJS({
57677
57677
  }
57678
57678
  });
57679
57679
 
57680
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/constants.js
57681
- var require_constants2 = __commonJS({
57682
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/constants.js"(exports, module) {
57683
- init_esm_shims();
57684
- var SEMVER_SPEC_VERSION = "2.0.0";
57685
- var MAX_LENGTH = 256;
57686
- var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
57687
- 9007199254740991;
57688
- var MAX_SAFE_COMPONENT_LENGTH = 16;
57689
- var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
57690
- var RELEASE_TYPES = [
57691
- "major",
57692
- "premajor",
57693
- "minor",
57694
- "preminor",
57695
- "patch",
57696
- "prepatch",
57697
- "prerelease"
57698
- ];
57699
- module.exports = {
57700
- MAX_LENGTH,
57701
- MAX_SAFE_COMPONENT_LENGTH,
57702
- MAX_SAFE_BUILD_LENGTH,
57703
- MAX_SAFE_INTEGER,
57704
- RELEASE_TYPES,
57705
- SEMVER_SPEC_VERSION,
57706
- FLAG_INCLUDE_PRERELEASE: 1,
57707
- FLAG_LOOSE: 2
57708
- };
57709
- }
57710
- });
57711
-
57712
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/debug.js
57713
- var require_debug3 = __commonJS({
57714
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/debug.js"(exports, module) {
57715
- init_esm_shims();
57716
- var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
57717
- };
57718
- module.exports = debug2;
57719
- }
57720
- });
57721
-
57722
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/re.js
57723
- var require_re2 = __commonJS({
57724
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/re.js"(exports, module) {
57725
- init_esm_shims();
57726
- var __import___constants = __toESM(require_constants2());
57727
- var __import___debug = __toESM(require_debug3());
57728
- var {
57729
- MAX_SAFE_COMPONENT_LENGTH,
57730
- MAX_SAFE_BUILD_LENGTH,
57731
- MAX_LENGTH
57732
- } = __import___constants;
57733
- var debug2 = __import___debug;
57734
- exports = module.exports = {};
57735
- var re2 = exports.re = [];
57736
- var safeRe = exports.safeRe = [];
57737
- var src = exports.src = [];
57738
- var safeSrc = exports.safeSrc = [];
57739
- var t = exports.t = {};
57740
- var R = 0;
57741
- var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
57742
- var safeRegexReplacements = [
57743
- ["\\s", 1],
57744
- ["\\d", MAX_LENGTH],
57745
- [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
57746
- ];
57747
- var makeSafeRegex = /* @__PURE__ */ __name((value) => {
57748
- for (const [token, max2] of safeRegexReplacements) {
57749
- value = value.split(`${token}*`).join(`${token}{0,${max2}}`).split(`${token}+`).join(`${token}{1,${max2}}`);
57750
- }
57751
- return value;
57752
- }, "makeSafeRegex");
57753
- var createToken = /* @__PURE__ */ __name((name, value, isGlobal) => {
57754
- const safe = makeSafeRegex(value);
57755
- const index = R++;
57756
- debug2(name, index, value);
57757
- t[name] = index;
57758
- src[index] = value;
57759
- safeSrc[index] = safe;
57760
- re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
57761
- safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
57762
- }, "createToken");
57763
- createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
57764
- createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
57765
- createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
57766
- createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
57767
- createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
57768
- createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
57769
- createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
57770
- createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
57771
- createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
57772
- createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
57773
- createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
57774
- createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
57775
- createToken("FULL", `^${src[t.FULLPLAIN]}$`);
57776
- createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
57777
- createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
57778
- createToken("GTLT", "((?:<|>)?=?)");
57779
- createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
57780
- createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
57781
- createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
57782
- createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
57783
- createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
57784
- createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
57785
- createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
57786
- createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
57787
- createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
57788
- createToken("COERCERTL", src[t.COERCE], true);
57789
- createToken("COERCERTLFULL", src[t.COERCEFULL], true);
57790
- createToken("LONETILDE", "(?:~>?)");
57791
- createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
57792
- exports.tildeTrimReplace = "$1~";
57793
- createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
57794
- createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
57795
- createToken("LONECARET", "(?:\\^)");
57796
- createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
57797
- exports.caretTrimReplace = "$1^";
57798
- createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
57799
- createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
57800
- createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
57801
- createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
57802
- createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
57803
- exports.comparatorTrimReplace = "$1$2$3";
57804
- createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
57805
- createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
57806
- createToken("STAR", "(<|>)?=?\\s*\\*");
57807
- createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
57808
- createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
57809
- }
57810
- });
57811
-
57812
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/parse-options.js
57813
- var require_parse_options2 = __commonJS({
57814
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/parse-options.js"(exports, module) {
57815
- init_esm_shims();
57816
- var looseOption = Object.freeze({
57817
- loose: true
57818
- });
57819
- var emptyOpts = Object.freeze({});
57820
- var parseOptions = /* @__PURE__ */ __name((options) => {
57821
- if (!options) {
57822
- return emptyOpts;
57823
- }
57824
- if (typeof options !== "object") {
57825
- return looseOption;
57826
- }
57827
- return options;
57828
- }, "parseOptions");
57829
- module.exports = parseOptions;
57830
- }
57831
- });
57832
-
57833
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/identifiers.js
57834
- var require_identifiers2 = __commonJS({
57835
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/identifiers.js"(exports, module) {
57836
- init_esm_shims();
57837
- var numeric = /^[0-9]+$/;
57838
- var compareIdentifiers = /* @__PURE__ */ __name((a, b) => {
57839
- const anum = numeric.test(a);
57840
- const bnum = numeric.test(b);
57841
- if (anum && bnum) {
57842
- a = +a;
57843
- b = +b;
57844
- }
57845
- return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
57846
- }, "compareIdentifiers");
57847
- var rcompareIdentifiers = /* @__PURE__ */ __name((a, b) => compareIdentifiers(b, a), "rcompareIdentifiers");
57848
- module.exports = {
57849
- compareIdentifiers,
57850
- rcompareIdentifiers
57851
- };
57852
- }
57853
- });
57854
-
57855
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/semver.js
57856
- var require_semver3 = __commonJS({
57857
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/semver.js"(exports, module) {
57858
- init_esm_shims();
57859
- var __import____internal_debug = __toESM(require_debug3());
57860
- var __import____internal_constants = __toESM(require_constants2());
57861
- var __import____internal_re = __toESM(require_re2());
57862
- var __import____internal_parseOptions = __toESM(require_parse_options2());
57863
- var __import____internal_identifiers = __toESM(require_identifiers2());
57864
- var debug2 = __import____internal_debug;
57865
- var { MAX_LENGTH, MAX_SAFE_INTEGER } = __import____internal_constants;
57866
- var { safeRe: re2, safeSrc: src, t } = __import____internal_re;
57867
- var parseOptions = __import____internal_parseOptions;
57868
- var { compareIdentifiers } = __import____internal_identifiers;
57869
- var SemVer = class _SemVer {
57870
- static {
57871
- __name(this, "SemVer");
57872
- }
57873
- constructor(version2, options) {
57874
- options = parseOptions(options);
57875
- if (version2 instanceof _SemVer) {
57876
- if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
57877
- return version2;
57878
- } else {
57879
- version2 = version2.version;
57880
- }
57881
- } else if (typeof version2 !== "string") {
57882
- throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
57883
- }
57884
- if (version2.length > MAX_LENGTH) {
57885
- throw new TypeError(
57886
- `version is longer than ${MAX_LENGTH} characters`
57887
- );
57888
- }
57889
- debug2("SemVer", version2, options);
57890
- this.options = options;
57891
- this.loose = !!options.loose;
57892
- this.includePrerelease = !!options.includePrerelease;
57893
- const m = version2.trim().match(options.loose ? re2[t.LOOSE] : re2[t.FULL]);
57894
- if (!m) {
57895
- throw new TypeError(`Invalid Version: ${version2}`);
57896
- }
57897
- this.raw = version2;
57898
- this.major = +m[1];
57899
- this.minor = +m[2];
57900
- this.patch = +m[3];
57901
- if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
57902
- throw new TypeError("Invalid major version");
57903
- }
57904
- if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
57905
- throw new TypeError("Invalid minor version");
57906
- }
57907
- if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
57908
- throw new TypeError("Invalid patch version");
57909
- }
57910
- if (!m[4]) {
57911
- this.prerelease = [];
57912
- } else {
57913
- this.prerelease = m[4].split(".").map((id) => {
57914
- if (/^[0-9]+$/.test(id)) {
57915
- const num2 = +id;
57916
- if (num2 >= 0 && num2 < MAX_SAFE_INTEGER) {
57917
- return num2;
57918
- }
57919
- }
57920
- return id;
57921
- });
57922
- }
57923
- this.build = m[5] ? m[5].split(".") : [];
57924
- this.format();
57925
- }
57926
- format() {
57927
- this.version = `${this.major}.${this.minor}.${this.patch}`;
57928
- if (this.prerelease.length) {
57929
- this.version += `-${this.prerelease.join(".")}`;
57930
- }
57931
- return this.version;
57932
- }
57933
- toString() {
57934
- return this.version;
57935
- }
57936
- compare(other) {
57937
- debug2("SemVer.compare", this.version, this.options, other);
57938
- if (!(other instanceof _SemVer)) {
57939
- if (typeof other === "string" && other === this.version) {
57940
- return 0;
57941
- }
57942
- other = new _SemVer(other, this.options);
57943
- }
57944
- if (other.version === this.version) {
57945
- return 0;
57946
- }
57947
- return this.compareMain(other) || this.comparePre(other);
57948
- }
57949
- compareMain(other) {
57950
- if (!(other instanceof _SemVer)) {
57951
- other = new _SemVer(other, this.options);
57952
- }
57953
- return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
57954
- }
57955
- comparePre(other) {
57956
- if (!(other instanceof _SemVer)) {
57957
- other = new _SemVer(other, this.options);
57958
- }
57959
- if (this.prerelease.length && !other.prerelease.length) {
57960
- return -1;
57961
- } else if (!this.prerelease.length && other.prerelease.length) {
57962
- return 1;
57963
- } else if (!this.prerelease.length && !other.prerelease.length) {
57964
- return 0;
57965
- }
57966
- let i = 0;
57967
- do {
57968
- const a = this.prerelease[i];
57969
- const b = other.prerelease[i];
57970
- debug2("prerelease compare", i, a, b);
57971
- if (a === void 0 && b === void 0) {
57972
- return 0;
57973
- } else if (b === void 0) {
57974
- return 1;
57975
- } else if (a === void 0) {
57976
- return -1;
57977
- } else if (a === b) {
57978
- continue;
57979
- } else {
57980
- return compareIdentifiers(a, b);
57981
- }
57982
- } while (++i);
57983
- }
57984
- compareBuild(other) {
57985
- if (!(other instanceof _SemVer)) {
57986
- other = new _SemVer(other, this.options);
57987
- }
57988
- let i = 0;
57989
- do {
57990
- const a = this.build[i];
57991
- const b = other.build[i];
57992
- debug2("build compare", i, a, b);
57993
- if (a === void 0 && b === void 0) {
57994
- return 0;
57995
- } else if (b === void 0) {
57996
- return 1;
57997
- } else if (a === void 0) {
57998
- return -1;
57999
- } else if (a === b) {
58000
- continue;
58001
- } else {
58002
- return compareIdentifiers(a, b);
58003
- }
58004
- } while (++i);
58005
- }
58006
- // preminor will bump the version up to the next minor release, and immediately
58007
- // down to pre-release. premajor and prepatch work the same way.
58008
- inc(release, identifier, identifierBase) {
58009
- if (release.startsWith("pre")) {
58010
- if (!identifier && identifierBase === false) {
58011
- throw new Error("invalid increment argument: identifier is empty");
58012
- }
58013
- if (identifier) {
58014
- const r = new RegExp(`^${this.options.loose ? src[t.PRERELEASELOOSE] : src[t.PRERELEASE]}$`);
58015
- const match = `-${identifier}`.match(r);
58016
- if (!match || match[1] !== identifier) {
58017
- throw new Error(`invalid identifier: ${identifier}`);
58018
- }
58019
- }
58020
- }
58021
- switch (release) {
58022
- case "premajor":
58023
- this.prerelease.length = 0;
58024
- this.patch = 0;
58025
- this.minor = 0;
58026
- this.major++;
58027
- this.inc("pre", identifier, identifierBase);
58028
- break;
58029
- case "preminor":
58030
- this.prerelease.length = 0;
58031
- this.patch = 0;
58032
- this.minor++;
58033
- this.inc("pre", identifier, identifierBase);
58034
- break;
58035
- case "prepatch":
58036
- this.prerelease.length = 0;
58037
- this.inc("patch", identifier, identifierBase);
58038
- this.inc("pre", identifier, identifierBase);
58039
- break;
58040
- // If the input is a non-prerelease version, this acts the same as
58041
- // prepatch.
58042
- case "prerelease":
58043
- if (this.prerelease.length === 0) {
58044
- this.inc("patch", identifier, identifierBase);
58045
- }
58046
- this.inc("pre", identifier, identifierBase);
58047
- break;
58048
- case "release":
58049
- if (this.prerelease.length === 0) {
58050
- throw new Error(`version ${this.raw} is not a prerelease`);
58051
- }
58052
- this.prerelease.length = 0;
58053
- break;
58054
- case "major":
58055
- if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
58056
- this.major++;
58057
- }
58058
- this.minor = 0;
58059
- this.patch = 0;
58060
- this.prerelease = [];
58061
- break;
58062
- case "minor":
58063
- if (this.patch !== 0 || this.prerelease.length === 0) {
58064
- this.minor++;
58065
- }
58066
- this.patch = 0;
58067
- this.prerelease = [];
58068
- break;
58069
- case "patch":
58070
- if (this.prerelease.length === 0) {
58071
- this.patch++;
58072
- }
58073
- this.prerelease = [];
58074
- break;
58075
- // This probably shouldn't be used publicly.
58076
- // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
58077
- case "pre": {
58078
- const base = Number(identifierBase) ? 1 : 0;
58079
- if (this.prerelease.length === 0) {
58080
- this.prerelease = [base];
58081
- } else {
58082
- let i = this.prerelease.length;
58083
- while (--i >= 0) {
58084
- if (typeof this.prerelease[i] === "number") {
58085
- this.prerelease[i]++;
58086
- i = -2;
58087
- }
58088
- }
58089
- if (i === -1) {
58090
- if (identifier === this.prerelease.join(".") && identifierBase === false) {
58091
- throw new Error("invalid increment argument: identifier already exists");
58092
- }
58093
- this.prerelease.push(base);
58094
- }
58095
- }
58096
- if (identifier) {
58097
- let prerelease = [identifier, base];
58098
- if (identifierBase === false) {
58099
- prerelease = [identifier];
58100
- }
58101
- if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
58102
- if (isNaN(this.prerelease[1])) {
58103
- this.prerelease = prerelease;
58104
- }
58105
- } else {
58106
- this.prerelease = prerelease;
58107
- }
58108
- }
58109
- break;
58110
- }
58111
- default:
58112
- throw new Error(`invalid increment argument: ${release}`);
58113
- }
58114
- this.raw = this.format();
58115
- if (this.build.length) {
58116
- this.raw += `+${this.build.join(".")}`;
58117
- }
58118
- return this;
58119
- }
58120
- };
58121
- module.exports = SemVer;
58122
- }
58123
- });
58124
-
58125
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/parse.js
58126
- var require_parse3 = __commonJS({
58127
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/parse.js"(exports, module) {
58128
- init_esm_shims();
58129
- var __import____classes_semver = __toESM(require_semver3());
58130
- var SemVer = __import____classes_semver;
58131
- var parse2 = /* @__PURE__ */ __name((version2, options, throwErrors = false) => {
58132
- if (version2 instanceof SemVer) {
58133
- return version2;
58134
- }
58135
- try {
58136
- return new SemVer(version2, options);
58137
- } catch (er) {
58138
- if (!throwErrors) {
58139
- return null;
58140
- }
58141
- throw er;
58142
- }
58143
- }, "parse");
58144
- module.exports = parse2;
58145
- }
58146
- });
58147
-
58148
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/valid.js
58149
- var require_valid3 = __commonJS({
58150
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/valid.js"(exports, module) {
58151
- init_esm_shims();
58152
- var __import___parse = __toESM(require_parse3());
58153
- var parse2 = __import___parse;
58154
- var valid2 = /* @__PURE__ */ __name((version2, options) => {
58155
- const v = parse2(version2, options);
58156
- return v ? v.version : null;
58157
- }, "valid");
58158
- module.exports = valid2;
58159
- }
58160
- });
58161
-
58162
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/clean.js
58163
- var require_clean2 = __commonJS({
58164
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/clean.js"(exports, module) {
58165
- init_esm_shims();
58166
- var __import___parse = __toESM(require_parse3());
58167
- var parse2 = __import___parse;
58168
- var clean = /* @__PURE__ */ __name((version2, options) => {
58169
- const s = parse2(version2.trim().replace(/^[=v]+/, ""), options);
58170
- return s ? s.version : null;
58171
- }, "clean");
58172
- module.exports = clean;
58173
- }
58174
- });
58175
-
58176
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/inc.js
58177
- var require_inc2 = __commonJS({
58178
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/inc.js"(exports, module) {
58179
- init_esm_shims();
58180
- var __import____classes_semver = __toESM(require_semver3());
58181
- var SemVer = __import____classes_semver;
58182
- var inc = /* @__PURE__ */ __name((version2, release, options, identifier, identifierBase) => {
58183
- if (typeof options === "string") {
58184
- identifierBase = identifier;
58185
- identifier = options;
58186
- options = void 0;
58187
- }
58188
- try {
58189
- return new SemVer(
58190
- version2 instanceof SemVer ? version2.version : version2,
58191
- options
58192
- ).inc(release, identifier, identifierBase).version;
58193
- } catch (er) {
58194
- return null;
58195
- }
58196
- }, "inc");
58197
- module.exports = inc;
58198
- }
58199
- });
58200
-
58201
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/diff.js
58202
- var require_diff2 = __commonJS({
58203
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/diff.js"(exports, module) {
58204
- init_esm_shims();
58205
- var __import___parse_js = __toESM(require_parse3());
58206
- var parse2 = __import___parse_js;
58207
- var diff = /* @__PURE__ */ __name((version1, version2) => {
58208
- const v1 = parse2(version1, null, true);
58209
- const v2 = parse2(version2, null, true);
58210
- const comparison = v1.compare(v2);
58211
- if (comparison === 0) {
58212
- return null;
58213
- }
58214
- const v1Higher = comparison > 0;
58215
- const highVersion = v1Higher ? v1 : v2;
58216
- const lowVersion = v1Higher ? v2 : v1;
58217
- const highHasPre = !!highVersion.prerelease.length;
58218
- const lowHasPre = !!lowVersion.prerelease.length;
58219
- if (lowHasPre && !highHasPre) {
58220
- if (!lowVersion.patch && !lowVersion.minor) {
58221
- return "major";
58222
- }
58223
- if (lowVersion.compareMain(highVersion) === 0) {
58224
- if (lowVersion.minor && !lowVersion.patch) {
58225
- return "minor";
58226
- }
58227
- return "patch";
58228
- }
58229
- }
58230
- const prefix = highHasPre ? "pre" : "";
58231
- if (v1.major !== v2.major) {
58232
- return prefix + "major";
58233
- }
58234
- if (v1.minor !== v2.minor) {
58235
- return prefix + "minor";
58236
- }
58237
- if (v1.patch !== v2.patch) {
58238
- return prefix + "patch";
58239
- }
58240
- return "prerelease";
58241
- }, "diff");
58242
- module.exports = diff;
58243
- }
58244
- });
58245
-
58246
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/major.js
58247
- var require_major2 = __commonJS({
58248
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/major.js"(exports, module) {
58249
- init_esm_shims();
58250
- var __import____classes_semver = __toESM(require_semver3());
58251
- var SemVer = __import____classes_semver;
58252
- var major2 = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).major, "major");
58253
- module.exports = major2;
58254
- }
58255
- });
58256
-
58257
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/minor.js
58258
- var require_minor2 = __commonJS({
58259
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/minor.js"(exports, module) {
58260
- init_esm_shims();
58261
- var __import____classes_semver = __toESM(require_semver3());
58262
- var SemVer = __import____classes_semver;
58263
- var minor = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).minor, "minor");
58264
- module.exports = minor;
58265
- }
58266
- });
58267
-
58268
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/patch.js
58269
- var require_patch2 = __commonJS({
58270
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/patch.js"(exports, module) {
58271
- init_esm_shims();
58272
- var __import____classes_semver = __toESM(require_semver3());
58273
- var SemVer = __import____classes_semver;
58274
- var patch = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).patch, "patch");
58275
- module.exports = patch;
58276
- }
58277
- });
58278
-
58279
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/prerelease.js
58280
- var require_prerelease2 = __commonJS({
58281
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/prerelease.js"(exports, module) {
58282
- init_esm_shims();
58283
- var __import___parse = __toESM(require_parse3());
58284
- var parse2 = __import___parse;
58285
- var prerelease = /* @__PURE__ */ __name((version2, options) => {
58286
- const parsed = parse2(version2, options);
58287
- return parsed && parsed.prerelease.length ? parsed.prerelease : null;
58288
- }, "prerelease");
58289
- module.exports = prerelease;
58290
- }
58291
- });
58292
-
58293
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare.js
58294
- var require_compare2 = __commonJS({
58295
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare.js"(exports, module) {
58296
- init_esm_shims();
58297
- var __import____classes_semver = __toESM(require_semver3());
58298
- var SemVer = __import____classes_semver;
58299
- var compare = /* @__PURE__ */ __name((a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose)), "compare");
58300
- module.exports = compare;
58301
- }
58302
- });
58303
-
58304
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/rcompare.js
58305
- var require_rcompare2 = __commonJS({
58306
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/rcompare.js"(exports, module) {
58307
- init_esm_shims();
58308
- var __import___compare = __toESM(require_compare2());
58309
- var compare = __import___compare;
58310
- var rcompare = /* @__PURE__ */ __name((a, b, loose) => compare(b, a, loose), "rcompare");
58311
- module.exports = rcompare;
58312
- }
58313
- });
58314
-
58315
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare-loose.js
58316
- var require_compare_loose2 = __commonJS({
58317
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare-loose.js"(exports, module) {
58318
- init_esm_shims();
58319
- var __import___compare = __toESM(require_compare2());
58320
- var compare = __import___compare;
58321
- var compareLoose = /* @__PURE__ */ __name((a, b) => compare(a, b, true), "compareLoose");
58322
- module.exports = compareLoose;
58323
- }
58324
- });
58325
-
58326
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare-build.js
58327
- var require_compare_build2 = __commonJS({
58328
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/compare-build.js"(exports, module) {
58329
- init_esm_shims();
58330
- var __import____classes_semver = __toESM(require_semver3());
58331
- var SemVer = __import____classes_semver;
58332
- var compareBuild = /* @__PURE__ */ __name((a, b, loose) => {
58333
- const versionA = new SemVer(a, loose);
58334
- const versionB = new SemVer(b, loose);
58335
- return versionA.compare(versionB) || versionA.compareBuild(versionB);
58336
- }, "compareBuild");
58337
- module.exports = compareBuild;
58338
- }
58339
- });
58340
-
58341
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/sort.js
58342
- var require_sort3 = __commonJS({
58343
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/sort.js"(exports, module) {
58344
- init_esm_shims();
58345
- var __import___compareBuild = __toESM(require_compare_build2());
58346
- var compareBuild = __import___compareBuild;
58347
- var sort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(a, b, loose)), "sort");
58348
- module.exports = sort;
58349
- }
58350
- });
58351
-
58352
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/rsort.js
58353
- var require_rsort2 = __commonJS({
58354
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/rsort.js"(exports, module) {
58355
- init_esm_shims();
58356
- var __import___compareBuild = __toESM(require_compare_build2());
58357
- var compareBuild = __import___compareBuild;
58358
- var rsort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b) => compareBuild(b, a, loose)), "rsort");
58359
- module.exports = rsort;
58360
- }
58361
- });
58362
-
58363
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/gt.js
58364
- var require_gt2 = __commonJS({
58365
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/gt.js"(exports, module) {
58366
- init_esm_shims();
58367
- var __import___compare = __toESM(require_compare2());
58368
- var compare = __import___compare;
58369
- var gt2 = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) > 0, "gt");
58370
- module.exports = gt2;
58371
- }
58372
- });
58373
-
58374
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/lt.js
58375
- var require_lt2 = __commonJS({
58376
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/lt.js"(exports, module) {
58377
- init_esm_shims();
58378
- var __import___compare = __toESM(require_compare2());
58379
- var compare = __import___compare;
58380
- var lt2 = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) < 0, "lt");
58381
- module.exports = lt2;
58382
- }
58383
- });
58384
-
58385
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/eq.js
58386
- var require_eq2 = __commonJS({
58387
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/eq.js"(exports, module) {
58388
- init_esm_shims();
58389
- var __import___compare = __toESM(require_compare2());
58390
- var compare = __import___compare;
58391
- var eq2 = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) === 0, "eq");
58392
- module.exports = eq2;
58393
- }
58394
- });
58395
-
58396
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/neq.js
58397
- var require_neq2 = __commonJS({
58398
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/neq.js"(exports, module) {
58399
- init_esm_shims();
58400
- var __import___compare = __toESM(require_compare2());
58401
- var compare = __import___compare;
58402
- var neq = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) !== 0, "neq");
58403
- module.exports = neq;
58404
- }
58405
- });
58406
-
58407
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/gte.js
58408
- var require_gte2 = __commonJS({
58409
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/gte.js"(exports, module) {
58410
- init_esm_shims();
58411
- var __import___compare = __toESM(require_compare2());
58412
- var compare = __import___compare;
58413
- var gte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) >= 0, "gte");
58414
- module.exports = gte;
58415
- }
58416
- });
58417
-
58418
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/lte.js
58419
- var require_lte2 = __commonJS({
58420
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/lte.js"(exports, module) {
58421
- init_esm_shims();
58422
- var __import___compare = __toESM(require_compare2());
58423
- var compare = __import___compare;
58424
- var lte = /* @__PURE__ */ __name((a, b, loose) => compare(a, b, loose) <= 0, "lte");
58425
- module.exports = lte;
58426
- }
58427
- });
58428
-
58429
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/cmp.js
58430
- var require_cmp2 = __commonJS({
58431
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/cmp.js"(exports, module) {
58432
- init_esm_shims();
58433
- var __import___eq = __toESM(require_eq2());
58434
- var __import___neq = __toESM(require_neq2());
58435
- var __import___gt = __toESM(require_gt2());
58436
- var __import___gte = __toESM(require_gte2());
58437
- var __import___lt = __toESM(require_lt2());
58438
- var __import___lte = __toESM(require_lte2());
58439
- var eq2 = __import___eq;
58440
- var neq = __import___neq;
58441
- var gt2 = __import___gt;
58442
- var gte = __import___gte;
58443
- var lt2 = __import___lt;
58444
- var lte = __import___lte;
58445
- var cmp = /* @__PURE__ */ __name((a, op, b, loose) => {
58446
- switch (op) {
58447
- case "===":
58448
- if (typeof a === "object") {
58449
- a = a.version;
58450
- }
58451
- if (typeof b === "object") {
58452
- b = b.version;
58453
- }
58454
- return a === b;
58455
- case "!==":
58456
- if (typeof a === "object") {
58457
- a = a.version;
58458
- }
58459
- if (typeof b === "object") {
58460
- b = b.version;
58461
- }
58462
- return a !== b;
58463
- case "":
58464
- case "=":
58465
- case "==":
58466
- return eq2(a, b, loose);
58467
- case "!=":
58468
- return neq(a, b, loose);
58469
- case ">":
58470
- return gt2(a, b, loose);
58471
- case ">=":
58472
- return gte(a, b, loose);
58473
- case "<":
58474
- return lt2(a, b, loose);
58475
- case "<=":
58476
- return lte(a, b, loose);
58477
- default:
58478
- throw new TypeError(`Invalid operator: ${op}`);
58479
- }
58480
- }, "cmp");
58481
- module.exports = cmp;
58482
- }
58483
- });
58484
-
58485
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/coerce.js
58486
- var require_coerce2 = __commonJS({
58487
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/coerce.js"(exports, module) {
58488
- init_esm_shims();
58489
- var __import____classes_semver = __toESM(require_semver3());
58490
- var __import___parse = __toESM(require_parse3());
58491
- var __import____internal_re = __toESM(require_re2());
58492
- var SemVer = __import____classes_semver;
58493
- var parse2 = __import___parse;
58494
- var { safeRe: re2, t } = __import____internal_re;
58495
- var coerce = /* @__PURE__ */ __name((version2, options) => {
58496
- if (version2 instanceof SemVer) {
58497
- return version2;
58498
- }
58499
- if (typeof version2 === "number") {
58500
- version2 = String(version2);
58501
- }
58502
- if (typeof version2 !== "string") {
58503
- return null;
58504
- }
58505
- options = options || {};
58506
- let match = null;
58507
- if (!options.rtl) {
58508
- match = version2.match(options.includePrerelease ? re2[t.COERCEFULL] : re2[t.COERCE]);
58509
- } else {
58510
- const coerceRtlRegex = options.includePrerelease ? re2[t.COERCERTLFULL] : re2[t.COERCERTL];
58511
- let next;
58512
- while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
58513
- if (!match || next.index + next[0].length !== match.index + match[0].length) {
58514
- match = next;
58515
- }
58516
- coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
58517
- }
58518
- coerceRtlRegex.lastIndex = -1;
58519
- }
58520
- if (match === null) {
58521
- return null;
58522
- }
58523
- const major2 = match[2];
58524
- const minor = match[3] || "0";
58525
- const patch = match[4] || "0";
58526
- const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
58527
- const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
58528
- return parse2(`${major2}.${minor}.${patch}${prerelease}${build}`, options);
58529
- }, "coerce");
58530
- module.exports = coerce;
58531
- }
58532
- });
58533
-
58534
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/lrucache.js
58535
- var require_lrucache2 = __commonJS({
58536
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/internal/lrucache.js"(exports, module) {
58537
- init_esm_shims();
58538
- var LRUCache = class LRUCache {
58539
- static {
58540
- __name(this, "LRUCache");
58541
- }
58542
- constructor() {
58543
- this.max = 1e3;
58544
- this.map = /* @__PURE__ */ new Map();
58545
- }
58546
- get(key) {
58547
- const value = this.map.get(key);
58548
- if (value === void 0) {
58549
- return void 0;
58550
- } else {
58551
- this.map.delete(key);
58552
- this.map.set(key, value);
58553
- return value;
58554
- }
58555
- }
58556
- delete(key) {
58557
- return this.map.delete(key);
58558
- }
58559
- set(key, value) {
58560
- const deleted = this.delete(key);
58561
- if (!deleted && value !== void 0) {
58562
- if (this.map.size >= this.max) {
58563
- const firstKey = this.map.keys().next().value;
58564
- this.delete(firstKey);
58565
- }
58566
- this.map.set(key, value);
58567
- }
58568
- return this;
58569
- }
58570
- };
58571
- module.exports = LRUCache;
58572
- }
58573
- });
58574
-
58575
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/range.js
58576
- var require_range3 = __commonJS({
58577
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/range.js"(exports, module) {
58578
- init_esm_shims();
58579
- var __import____internal_lrucache = __toESM(require_lrucache2());
58580
- var __import____internal_parseOptions = __toESM(require_parse_options2());
58581
- var __import___comparator = __toESM(require_comparator2());
58582
- var __import____internal_debug = __toESM(require_debug3());
58583
- var __import___semver = __toESM(require_semver3());
58584
- var __import____internal_re = __toESM(require_re2());
58585
- var __import____internal_constants = __toESM(require_constants2());
58586
- var SPACE_CHARACTERS = /\s+/g;
58587
- var Range = class _Range {
58588
- static {
58589
- __name(this, "Range");
58590
- }
58591
- constructor(range3, options) {
58592
- options = parseOptions(options);
58593
- if (range3 instanceof _Range) {
58594
- if (range3.loose === !!options.loose && range3.includePrerelease === !!options.includePrerelease) {
58595
- return range3;
58596
- } else {
58597
- return new _Range(range3.raw, options);
58598
- }
58599
- }
58600
- if (range3 instanceof Comparator) {
58601
- this.raw = range3.value;
58602
- this.set = [[range3]];
58603
- this.formatted = void 0;
58604
- return this;
58605
- }
58606
- this.options = options;
58607
- this.loose = !!options.loose;
58608
- this.includePrerelease = !!options.includePrerelease;
58609
- this.raw = range3.trim().replace(SPACE_CHARACTERS, " ");
58610
- this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
58611
- if (!this.set.length) {
58612
- throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
58613
- }
58614
- if (this.set.length > 1) {
58615
- const first2 = this.set[0];
58616
- this.set = this.set.filter((c) => !isNullSet(c[0]));
58617
- if (this.set.length === 0) {
58618
- this.set = [first2];
58619
- } else if (this.set.length > 1) {
58620
- for (const c of this.set) {
58621
- if (c.length === 1 && isAny(c[0])) {
58622
- this.set = [c];
58623
- break;
58624
- }
58625
- }
58626
- }
58627
- }
58628
- this.formatted = void 0;
58629
- }
58630
- get range() {
58631
- if (this.formatted === void 0) {
58632
- this.formatted = "";
58633
- for (let i = 0; i < this.set.length; i++) {
58634
- if (i > 0) {
58635
- this.formatted += "||";
58636
- }
58637
- const comps = this.set[i];
58638
- for (let k = 0; k < comps.length; k++) {
58639
- if (k > 0) {
58640
- this.formatted += " ";
58641
- }
58642
- this.formatted += comps[k].toString().trim();
58643
- }
58644
- }
58645
- }
58646
- return this.formatted;
58647
- }
58648
- format() {
58649
- return this.range;
58650
- }
58651
- toString() {
58652
- return this.range;
58653
- }
58654
- parseRange(range3) {
58655
- const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
58656
- const memoKey = memoOpts + ":" + range3;
58657
- const cached = cache.get(memoKey);
58658
- if (cached) {
58659
- return cached;
58660
- }
58661
- const loose = this.options.loose;
58662
- const hr = loose ? re2[t.HYPHENRANGELOOSE] : re2[t.HYPHENRANGE];
58663
- range3 = range3.replace(hr, hyphenReplace(this.options.includePrerelease));
58664
- debug2("hyphen replace", range3);
58665
- range3 = range3.replace(re2[t.COMPARATORTRIM], comparatorTrimReplace);
58666
- debug2("comparator trim", range3);
58667
- range3 = range3.replace(re2[t.TILDETRIM], tildeTrimReplace);
58668
- debug2("tilde trim", range3);
58669
- range3 = range3.replace(re2[t.CARETTRIM], caretTrimReplace);
58670
- debug2("caret trim", range3);
58671
- let rangeList = range3.split(" ").map((comp2) => parseComparator(comp2, this.options)).join(" ").split(/\s+/).map((comp2) => replaceGTE0(comp2, this.options));
58672
- if (loose) {
58673
- rangeList = rangeList.filter((comp2) => {
58674
- debug2("loose invalid filter", comp2, this.options);
58675
- return !!comp2.match(re2[t.COMPARATORLOOSE]);
58676
- });
58677
- }
58678
- debug2("range list", rangeList);
58679
- const rangeMap = /* @__PURE__ */ new Map();
58680
- const comparators = rangeList.map((comp2) => new Comparator(comp2, this.options));
58681
- for (const comp2 of comparators) {
58682
- if (isNullSet(comp2)) {
58683
- return [comp2];
58684
- }
58685
- rangeMap.set(comp2.value, comp2);
58686
- }
58687
- if (rangeMap.size > 1 && rangeMap.has("")) {
58688
- rangeMap.delete("");
58689
- }
58690
- const result2 = [...rangeMap.values()];
58691
- cache.set(memoKey, result2);
58692
- return result2;
58693
- }
58694
- intersects(range3, options) {
58695
- if (!(range3 instanceof _Range)) {
58696
- throw new TypeError("a Range is required");
58697
- }
58698
- return this.set.some((thisComparators) => {
58699
- return isSatisfiable(thisComparators, options) && range3.set.some((rangeComparators) => {
58700
- return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
58701
- return rangeComparators.every((rangeComparator) => {
58702
- return thisComparator.intersects(rangeComparator, options);
58703
- });
58704
- });
58705
- });
58706
- });
58707
- }
58708
- // if ANY of the sets match ALL of its comparators, then pass
58709
- test(version2) {
58710
- if (!version2) {
58711
- return false;
58712
- }
58713
- if (typeof version2 === "string") {
58714
- try {
58715
- version2 = new SemVer(version2, this.options);
58716
- } catch (er) {
58717
- return false;
58718
- }
58719
- }
58720
- for (let i = 0; i < this.set.length; i++) {
58721
- if (testSet(this.set[i], version2, this.options)) {
58722
- return true;
58723
- }
58724
- }
58725
- return false;
58726
- }
58727
- };
58728
- module.exports = Range;
58729
- var LRU = __import____internal_lrucache;
58730
- var cache = new LRU();
58731
- var parseOptions = __import____internal_parseOptions;
58732
- var Comparator = __import___comparator;
58733
- var debug2 = __import____internal_debug;
58734
- var SemVer = __import___semver;
58735
- var {
58736
- safeRe: re2,
58737
- t,
58738
- comparatorTrimReplace,
58739
- tildeTrimReplace,
58740
- caretTrimReplace
58741
- } = __import____internal_re;
58742
- var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = __import____internal_constants;
58743
- var isNullSet = /* @__PURE__ */ __name((c) => c.value === "<0.0.0-0", "isNullSet");
58744
- var isAny = /* @__PURE__ */ __name((c) => c.value === "", "isAny");
58745
- var isSatisfiable = /* @__PURE__ */ __name((comparators, options) => {
58746
- let result2 = true;
58747
- const remainingComparators = comparators.slice();
58748
- let testComparator = remainingComparators.pop();
58749
- while (result2 && remainingComparators.length) {
58750
- result2 = remainingComparators.every((otherComparator) => {
58751
- return testComparator.intersects(otherComparator, options);
58752
- });
58753
- testComparator = remainingComparators.pop();
58754
- }
58755
- return result2;
58756
- }, "isSatisfiable");
58757
- var parseComparator = /* @__PURE__ */ __name((comp2, options) => {
58758
- debug2("comp", comp2, options);
58759
- comp2 = replaceCarets(comp2, options);
58760
- debug2("caret", comp2);
58761
- comp2 = replaceTildes(comp2, options);
58762
- debug2("tildes", comp2);
58763
- comp2 = replaceXRanges(comp2, options);
58764
- debug2("xrange", comp2);
58765
- comp2 = replaceStars(comp2, options);
58766
- debug2("stars", comp2);
58767
- return comp2;
58768
- }, "parseComparator");
58769
- var isX = /* @__PURE__ */ __name((id) => !id || id.toLowerCase() === "x" || id === "*", "isX");
58770
- var replaceTildes = /* @__PURE__ */ __name((comp2, options) => {
58771
- return comp2.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
58772
- }, "replaceTildes");
58773
- var replaceTilde = /* @__PURE__ */ __name((comp2, options) => {
58774
- const r = options.loose ? re2[t.TILDELOOSE] : re2[t.TILDE];
58775
- return comp2.replace(r, (_3, M, m, p, pr2) => {
58776
- debug2("tilde", comp2, _3, M, m, p, pr2);
58777
- let ret;
58778
- if (isX(M)) {
58779
- ret = "";
58780
- } else if (isX(m)) {
58781
- ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
58782
- } else if (isX(p)) {
58783
- ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
58784
- } else if (pr2) {
58785
- debug2("replaceTilde pr", pr2);
58786
- ret = `>=${M}.${m}.${p}-${pr2} <${M}.${+m + 1}.0-0`;
58787
- } else {
58788
- ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
58789
- }
58790
- debug2("tilde return", ret);
58791
- return ret;
58792
- });
58793
- }, "replaceTilde");
58794
- var replaceCarets = /* @__PURE__ */ __name((comp2, options) => {
58795
- return comp2.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
58796
- }, "replaceCarets");
58797
- var replaceCaret = /* @__PURE__ */ __name((comp2, options) => {
58798
- debug2("caret", comp2, options);
58799
- const r = options.loose ? re2[t.CARETLOOSE] : re2[t.CARET];
58800
- const z = options.includePrerelease ? "-0" : "";
58801
- return comp2.replace(r, (_3, M, m, p, pr2) => {
58802
- debug2("caret", comp2, _3, M, m, p, pr2);
58803
- let ret;
58804
- if (isX(M)) {
58805
- ret = "";
58806
- } else if (isX(m)) {
58807
- ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
58808
- } else if (isX(p)) {
58809
- if (M === "0") {
58810
- ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
58811
- } else {
58812
- ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
58813
- }
58814
- } else if (pr2) {
58815
- debug2("replaceCaret pr", pr2);
58816
- if (M === "0") {
58817
- if (m === "0") {
58818
- ret = `>=${M}.${m}.${p}-${pr2} <${M}.${m}.${+p + 1}-0`;
58819
- } else {
58820
- ret = `>=${M}.${m}.${p}-${pr2} <${M}.${+m + 1}.0-0`;
58821
- }
58822
- } else {
58823
- ret = `>=${M}.${m}.${p}-${pr2} <${+M + 1}.0.0-0`;
58824
- }
58825
- } else {
58826
- debug2("no pr");
58827
- if (M === "0") {
58828
- if (m === "0") {
58829
- ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
58830
- } else {
58831
- ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
58832
- }
58833
- } else {
58834
- ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
58835
- }
58836
- }
58837
- debug2("caret return", ret);
58838
- return ret;
58839
- });
58840
- }, "replaceCaret");
58841
- var replaceXRanges = /* @__PURE__ */ __name((comp2, options) => {
58842
- debug2("replaceXRanges", comp2, options);
58843
- return comp2.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
58844
- }, "replaceXRanges");
58845
- var replaceXRange = /* @__PURE__ */ __name((comp2, options) => {
58846
- comp2 = comp2.trim();
58847
- const r = options.loose ? re2[t.XRANGELOOSE] : re2[t.XRANGE];
58848
- return comp2.replace(r, (ret, gtlt, M, m, p, pr2) => {
58849
- debug2("xRange", comp2, ret, gtlt, M, m, p, pr2);
58850
- const xM = isX(M);
58851
- const xm = xM || isX(m);
58852
- const xp = xm || isX(p);
58853
- const anyX = xp;
58854
- if (gtlt === "=" && anyX) {
58855
- gtlt = "";
58856
- }
58857
- pr2 = options.includePrerelease ? "-0" : "";
58858
- if (xM) {
58859
- if (gtlt === ">" || gtlt === "<") {
58860
- ret = "<0.0.0-0";
58861
- } else {
58862
- ret = "*";
58863
- }
58864
- } else if (gtlt && anyX) {
58865
- if (xm) {
58866
- m = 0;
58867
- }
58868
- p = 0;
58869
- if (gtlt === ">") {
58870
- gtlt = ">=";
58871
- if (xm) {
58872
- M = +M + 1;
58873
- m = 0;
58874
- p = 0;
58875
- } else {
58876
- m = +m + 1;
58877
- p = 0;
58878
- }
58879
- } else if (gtlt === "<=") {
58880
- gtlt = "<";
58881
- if (xm) {
58882
- M = +M + 1;
58883
- } else {
58884
- m = +m + 1;
58885
- }
58886
- }
58887
- if (gtlt === "<") {
58888
- pr2 = "-0";
58889
- }
58890
- ret = `${gtlt + M}.${m}.${p}${pr2}`;
58891
- } else if (xm) {
58892
- ret = `>=${M}.0.0${pr2} <${+M + 1}.0.0-0`;
58893
- } else if (xp) {
58894
- ret = `>=${M}.${m}.0${pr2} <${M}.${+m + 1}.0-0`;
58895
- }
58896
- debug2("xRange return", ret);
58897
- return ret;
58898
- });
58899
- }, "replaceXRange");
58900
- var replaceStars = /* @__PURE__ */ __name((comp2, options) => {
58901
- debug2("replaceStars", comp2, options);
58902
- return comp2.trim().replace(re2[t.STAR], "");
58903
- }, "replaceStars");
58904
- var replaceGTE0 = /* @__PURE__ */ __name((comp2, options) => {
58905
- debug2("replaceGTE0", comp2, options);
58906
- return comp2.trim().replace(re2[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
58907
- }, "replaceGTE0");
58908
- var hyphenReplace = /* @__PURE__ */ __name((incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
58909
- if (isX(fM)) {
58910
- from = "";
58911
- } else if (isX(fm)) {
58912
- from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
58913
- } else if (isX(fp)) {
58914
- from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
58915
- } else if (fpr) {
58916
- from = `>=${from}`;
58917
- } else {
58918
- from = `>=${from}${incPr ? "-0" : ""}`;
58919
- }
58920
- if (isX(tM)) {
58921
- to = "";
58922
- } else if (isX(tm)) {
58923
- to = `<${+tM + 1}.0.0-0`;
58924
- } else if (isX(tp)) {
58925
- to = `<${tM}.${+tm + 1}.0-0`;
58926
- } else if (tpr) {
58927
- to = `<=${tM}.${tm}.${tp}-${tpr}`;
58928
- } else if (incPr) {
58929
- to = `<${tM}.${tm}.${+tp + 1}-0`;
58930
- } else {
58931
- to = `<=${to}`;
58932
- }
58933
- return `${from} ${to}`.trim();
58934
- }, "hyphenReplace");
58935
- var testSet = /* @__PURE__ */ __name((set, version2, options) => {
58936
- for (let i = 0; i < set.length; i++) {
58937
- if (!set[i].test(version2)) {
58938
- return false;
58939
- }
58940
- }
58941
- if (version2.prerelease.length && !options.includePrerelease) {
58942
- for (let i = 0; i < set.length; i++) {
58943
- debug2(set[i].semver);
58944
- if (set[i].semver === Comparator.ANY) {
58945
- continue;
58946
- }
58947
- if (set[i].semver.prerelease.length > 0) {
58948
- const allowed = set[i].semver;
58949
- if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
58950
- return true;
58951
- }
58952
- }
58953
- }
58954
- return false;
58955
- }
58956
- return true;
58957
- }, "testSet");
58958
- }
58959
- });
58960
-
58961
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/comparator.js
58962
- var require_comparator2 = __commonJS({
58963
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/classes/comparator.js"(exports, module) {
58964
- init_esm_shims();
58965
- var __import____internal_parseOptions = __toESM(require_parse_options2());
58966
- var __import____internal_re = __toESM(require_re2());
58967
- var __import____functions_cmp = __toESM(require_cmp2());
58968
- var __import____internal_debug = __toESM(require_debug3());
58969
- var __import___semver = __toESM(require_semver3());
58970
- var __import___range = __toESM(require_range3());
58971
- var ANY = Symbol("SemVer ANY");
58972
- var Comparator = class _Comparator {
58973
- static {
58974
- __name(this, "Comparator");
58975
- }
58976
- static get ANY() {
58977
- return ANY;
58978
- }
58979
- constructor(comp2, options) {
58980
- options = parseOptions(options);
58981
- if (comp2 instanceof _Comparator) {
58982
- if (comp2.loose === !!options.loose) {
58983
- return comp2;
58984
- } else {
58985
- comp2 = comp2.value;
58986
- }
58987
- }
58988
- comp2 = comp2.trim().split(/\s+/).join(" ");
58989
- debug2("comparator", comp2, options);
58990
- this.options = options;
58991
- this.loose = !!options.loose;
58992
- this.parse(comp2);
58993
- if (this.semver === ANY) {
58994
- this.value = "";
58995
- } else {
58996
- this.value = this.operator + this.semver.version;
58997
- }
58998
- debug2("comp", this);
58999
- }
59000
- parse(comp2) {
59001
- const r = this.options.loose ? re2[t.COMPARATORLOOSE] : re2[t.COMPARATOR];
59002
- const m = comp2.match(r);
59003
- if (!m) {
59004
- throw new TypeError(`Invalid comparator: ${comp2}`);
59005
- }
59006
- this.operator = m[1] !== void 0 ? m[1] : "";
59007
- if (this.operator === "=") {
59008
- this.operator = "";
59009
- }
59010
- if (!m[2]) {
59011
- this.semver = ANY;
59012
- } else {
59013
- this.semver = new SemVer(m[2], this.options.loose);
59014
- }
59015
- }
59016
- toString() {
59017
- return this.value;
59018
- }
59019
- test(version2) {
59020
- debug2("Comparator.test", version2, this.options.loose);
59021
- if (this.semver === ANY || version2 === ANY) {
59022
- return true;
59023
- }
59024
- if (typeof version2 === "string") {
59025
- try {
59026
- version2 = new SemVer(version2, this.options);
59027
- } catch (er) {
59028
- return false;
59029
- }
59030
- }
59031
- return cmp(version2, this.operator, this.semver, this.options);
59032
- }
59033
- intersects(comp2, options) {
59034
- if (!(comp2 instanceof _Comparator)) {
59035
- throw new TypeError("a Comparator is required");
59036
- }
59037
- if (this.operator === "") {
59038
- if (this.value === "") {
59039
- return true;
59040
- }
59041
- return new Range(comp2.value, options).test(this.value);
59042
- } else if (comp2.operator === "") {
59043
- if (comp2.value === "") {
59044
- return true;
59045
- }
59046
- return new Range(this.value, options).test(comp2.semver);
59047
- }
59048
- options = parseOptions(options);
59049
- if (options.includePrerelease && (this.value === "<0.0.0-0" || comp2.value === "<0.0.0-0")) {
59050
- return false;
59051
- }
59052
- if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp2.value.startsWith("<0.0.0"))) {
59053
- return false;
59054
- }
59055
- if (this.operator.startsWith(">") && comp2.operator.startsWith(">")) {
59056
- return true;
59057
- }
59058
- if (this.operator.startsWith("<") && comp2.operator.startsWith("<")) {
59059
- return true;
59060
- }
59061
- if (this.semver.version === comp2.semver.version && this.operator.includes("=") && comp2.operator.includes("=")) {
59062
- return true;
59063
- }
59064
- if (cmp(this.semver, "<", comp2.semver, options) && this.operator.startsWith(">") && comp2.operator.startsWith("<")) {
59065
- return true;
59066
- }
59067
- if (cmp(this.semver, ">", comp2.semver, options) && this.operator.startsWith("<") && comp2.operator.startsWith(">")) {
59068
- return true;
59069
- }
59070
- return false;
59071
- }
59072
- };
59073
- module.exports = Comparator;
59074
- var parseOptions = __import____internal_parseOptions;
59075
- var { safeRe: re2, t } = __import____internal_re;
59076
- var cmp = __import____functions_cmp;
59077
- var debug2 = __import____internal_debug;
59078
- var SemVer = __import___semver;
59079
- var Range = __import___range;
59080
- }
59081
- });
59082
-
59083
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/satisfies.js
59084
- var require_satisfies2 = __commonJS({
59085
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/functions/satisfies.js"(exports, module) {
59086
- init_esm_shims();
59087
- var __import____classes_range = __toESM(require_range3());
59088
- var Range = __import____classes_range;
59089
- var satisfies = /* @__PURE__ */ __name((version2, range3, options) => {
59090
- try {
59091
- range3 = new Range(range3, options);
59092
- } catch (er) {
59093
- return false;
59094
- }
59095
- return range3.test(version2);
59096
- }, "satisfies");
59097
- module.exports = satisfies;
59098
- }
59099
- });
59100
-
59101
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/to-comparators.js
59102
- var require_to_comparators2 = __commonJS({
59103
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/to-comparators.js"(exports, module) {
59104
- init_esm_shims();
59105
- var __import____classes_range = __toESM(require_range3());
59106
- var Range = __import____classes_range;
59107
- var toComparators = /* @__PURE__ */ __name((range3, options) => new Range(range3, options).set.map((comp2) => comp2.map((c) => c.value).join(" ").trim().split(" ")), "toComparators");
59108
- module.exports = toComparators;
59109
- }
59110
- });
59111
-
59112
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/max-satisfying.js
59113
- var require_max_satisfying2 = __commonJS({
59114
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
59115
- init_esm_shims();
59116
- var __import____classes_semver = __toESM(require_semver3());
59117
- var __import____classes_range = __toESM(require_range3());
59118
- var SemVer = __import____classes_semver;
59119
- var Range = __import____classes_range;
59120
- var maxSatisfying = /* @__PURE__ */ __name((versions, range3, options) => {
59121
- let max2 = null;
59122
- let maxSV = null;
59123
- let rangeObj = null;
59124
- try {
59125
- rangeObj = new Range(range3, options);
59126
- } catch (er) {
59127
- return null;
59128
- }
59129
- versions.forEach((v) => {
59130
- if (rangeObj.test(v)) {
59131
- if (!max2 || maxSV.compare(v) === -1) {
59132
- max2 = v;
59133
- maxSV = new SemVer(max2, options);
59134
- }
59135
- }
59136
- });
59137
- return max2;
59138
- }, "maxSatisfying");
59139
- module.exports = maxSatisfying;
59140
- }
59141
- });
59142
-
59143
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/min-satisfying.js
59144
- var require_min_satisfying2 = __commonJS({
59145
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
59146
- init_esm_shims();
59147
- var __import____classes_semver = __toESM(require_semver3());
59148
- var __import____classes_range = __toESM(require_range3());
59149
- var SemVer = __import____classes_semver;
59150
- var Range = __import____classes_range;
59151
- var minSatisfying = /* @__PURE__ */ __name((versions, range3, options) => {
59152
- let min2 = null;
59153
- let minSV = null;
59154
- let rangeObj = null;
59155
- try {
59156
- rangeObj = new Range(range3, options);
59157
- } catch (er) {
59158
- return null;
59159
- }
59160
- versions.forEach((v) => {
59161
- if (rangeObj.test(v)) {
59162
- if (!min2 || minSV.compare(v) === 1) {
59163
- min2 = v;
59164
- minSV = new SemVer(min2, options);
59165
- }
59166
- }
59167
- });
59168
- return min2;
59169
- }, "minSatisfying");
59170
- module.exports = minSatisfying;
59171
- }
59172
- });
59173
-
59174
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/min-version.js
59175
- var require_min_version2 = __commonJS({
59176
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/min-version.js"(exports, module) {
59177
- init_esm_shims();
59178
- var __import____classes_semver = __toESM(require_semver3());
59179
- var __import____classes_range = __toESM(require_range3());
59180
- var __import____functions_gt = __toESM(require_gt2());
59181
- var SemVer = __import____classes_semver;
59182
- var Range = __import____classes_range;
59183
- var gt2 = __import____functions_gt;
59184
- var minVersion = /* @__PURE__ */ __name((range3, loose) => {
59185
- range3 = new Range(range3, loose);
59186
- let minver = new SemVer("0.0.0");
59187
- if (range3.test(minver)) {
59188
- return minver;
59189
- }
59190
- minver = new SemVer("0.0.0-0");
59191
- if (range3.test(minver)) {
59192
- return minver;
59193
- }
59194
- minver = null;
59195
- for (let i = 0; i < range3.set.length; ++i) {
59196
- const comparators = range3.set[i];
59197
- let setMin = null;
59198
- comparators.forEach((comparator) => {
59199
- const compver = new SemVer(comparator.semver.version);
59200
- switch (comparator.operator) {
59201
- case ">":
59202
- if (compver.prerelease.length === 0) {
59203
- compver.patch++;
59204
- } else {
59205
- compver.prerelease.push(0);
59206
- }
59207
- compver.raw = compver.format();
59208
- /* fallthrough */
59209
- case "":
59210
- case ">=":
59211
- if (!setMin || gt2(compver, setMin)) {
59212
- setMin = compver;
59213
- }
59214
- break;
59215
- case "<":
59216
- case "<=":
59217
- break;
59218
- /* istanbul ignore next */
59219
- default:
59220
- throw new Error(`Unexpected operation: ${comparator.operator}`);
59221
- }
59222
- });
59223
- if (setMin && (!minver || gt2(minver, setMin))) {
59224
- minver = setMin;
59225
- }
59226
- }
59227
- if (minver && range3.test(minver)) {
59228
- return minver;
59229
- }
59230
- return null;
59231
- }, "minVersion");
59232
- module.exports = minVersion;
59233
- }
59234
- });
59235
-
59236
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/valid.js
59237
- var require_valid4 = __commonJS({
59238
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/valid.js"(exports, module) {
59239
- init_esm_shims();
59240
- var __import____classes_range = __toESM(require_range3());
59241
- var Range = __import____classes_range;
59242
- var validRange = /* @__PURE__ */ __name((range3, options) => {
59243
- try {
59244
- return new Range(range3, options).range || "*";
59245
- } catch (er) {
59246
- return null;
59247
- }
59248
- }, "validRange");
59249
- module.exports = validRange;
59250
- }
59251
- });
59252
-
59253
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/outside.js
59254
- var require_outside2 = __commonJS({
59255
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/outside.js"(exports, module) {
59256
- init_esm_shims();
59257
- var __import____classes_semver = __toESM(require_semver3());
59258
- var __import____classes_comparator = __toESM(require_comparator2());
59259
- var __import____classes_range = __toESM(require_range3());
59260
- var __import____functions_satisfies = __toESM(require_satisfies2());
59261
- var __import____functions_gt = __toESM(require_gt2());
59262
- var __import____functions_lt = __toESM(require_lt2());
59263
- var __import____functions_lte = __toESM(require_lte2());
59264
- var __import____functions_gte = __toESM(require_gte2());
59265
- var SemVer = __import____classes_semver;
59266
- var Comparator = __import____classes_comparator;
59267
- var { ANY } = Comparator;
59268
- var Range = __import____classes_range;
59269
- var satisfies = __import____functions_satisfies;
59270
- var gt2 = __import____functions_gt;
59271
- var lt2 = __import____functions_lt;
59272
- var lte = __import____functions_lte;
59273
- var gte = __import____functions_gte;
59274
- var outside = /* @__PURE__ */ __name((version2, range3, hilo, options) => {
59275
- version2 = new SemVer(version2, options);
59276
- range3 = new Range(range3, options);
59277
- let gtfn, ltefn, ltfn, comp2, ecomp;
59278
- switch (hilo) {
59279
- case ">":
59280
- gtfn = gt2;
59281
- ltefn = lte;
59282
- ltfn = lt2;
59283
- comp2 = ">";
59284
- ecomp = ">=";
59285
- break;
59286
- case "<":
59287
- gtfn = lt2;
59288
- ltefn = gte;
59289
- ltfn = gt2;
59290
- comp2 = "<";
59291
- ecomp = "<=";
59292
- break;
59293
- default:
59294
- throw new TypeError('Must provide a hilo val of "<" or ">"');
59295
- }
59296
- if (satisfies(version2, range3, options)) {
59297
- return false;
59298
- }
59299
- for (let i = 0; i < range3.set.length; ++i) {
59300
- const comparators = range3.set[i];
59301
- let high = null;
59302
- let low = null;
59303
- comparators.forEach((comparator) => {
59304
- if (comparator.semver === ANY) {
59305
- comparator = new Comparator(">=0.0.0");
59306
- }
59307
- high = high || comparator;
59308
- low = low || comparator;
59309
- if (gtfn(comparator.semver, high.semver, options)) {
59310
- high = comparator;
59311
- } else if (ltfn(comparator.semver, low.semver, options)) {
59312
- low = comparator;
59313
- }
59314
- });
59315
- if (high.operator === comp2 || high.operator === ecomp) {
59316
- return false;
59317
- }
59318
- if ((!low.operator || low.operator === comp2) && ltefn(version2, low.semver)) {
59319
- return false;
59320
- } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
59321
- return false;
59322
- }
59323
- }
59324
- return true;
59325
- }, "outside");
59326
- module.exports = outside;
59327
- }
59328
- });
59329
-
59330
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/gtr.js
59331
- var require_gtr2 = __commonJS({
59332
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/gtr.js"(exports, module) {
59333
- init_esm_shims();
59334
- var __import___outside = __toESM(require_outside2());
59335
- var outside = __import___outside;
59336
- var gtr = /* @__PURE__ */ __name((version2, range3, options) => outside(version2, range3, ">", options), "gtr");
59337
- module.exports = gtr;
59338
- }
59339
- });
59340
-
59341
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/ltr.js
59342
- var require_ltr2 = __commonJS({
59343
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/ltr.js"(exports, module) {
59344
- init_esm_shims();
59345
- var __import___outside = __toESM(require_outside2());
59346
- var outside = __import___outside;
59347
- var ltr = /* @__PURE__ */ __name((version2, range3, options) => outside(version2, range3, "<", options), "ltr");
59348
- module.exports = ltr;
59349
- }
59350
- });
59351
-
59352
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/intersects.js
59353
- var require_intersects2 = __commonJS({
59354
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/intersects.js"(exports, module) {
59355
- init_esm_shims();
59356
- var __import____classes_range = __toESM(require_range3());
59357
- var Range = __import____classes_range;
59358
- var intersects = /* @__PURE__ */ __name((r1, r2, options) => {
59359
- r1 = new Range(r1, options);
59360
- r2 = new Range(r2, options);
59361
- return r1.intersects(r2, options);
59362
- }, "intersects");
59363
- module.exports = intersects;
59364
- }
59365
- });
59366
-
59367
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/simplify.js
59368
- var require_simplify2 = __commonJS({
59369
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/simplify.js"(exports, module) {
59370
- init_esm_shims();
59371
- var __import____functions_satisfies_js = __toESM(require_satisfies2());
59372
- var __import____functions_compare_js = __toESM(require_compare2());
59373
- var satisfies = __import____functions_satisfies_js;
59374
- var compare = __import____functions_compare_js;
59375
- module.exports = (versions, range3, options) => {
59376
- const set = [];
59377
- let first2 = null;
59378
- let prev = null;
59379
- const v = versions.sort((a, b) => compare(a, b, options));
59380
- for (const version2 of v) {
59381
- const included = satisfies(version2, range3, options);
59382
- if (included) {
59383
- prev = version2;
59384
- if (!first2) {
59385
- first2 = version2;
59386
- }
59387
- } else {
59388
- if (prev) {
59389
- set.push([first2, prev]);
59390
- }
59391
- prev = null;
59392
- first2 = null;
59393
- }
59394
- }
59395
- if (first2) {
59396
- set.push([first2, null]);
59397
- }
59398
- const ranges = [];
59399
- for (const [min2, max2] of set) {
59400
- if (min2 === max2) {
59401
- ranges.push(min2);
59402
- } else if (!max2 && min2 === v[0]) {
59403
- ranges.push("*");
59404
- } else if (!max2) {
59405
- ranges.push(`>=${min2}`);
59406
- } else if (min2 === v[0]) {
59407
- ranges.push(`<=${max2}`);
59408
- } else {
59409
- ranges.push(`${min2} - ${max2}`);
59410
- }
59411
- }
59412
- const simplified = ranges.join(" || ");
59413
- const original = typeof range3.raw === "string" ? range3.raw : String(range3);
59414
- return simplified.length < original.length ? simplified : range3;
59415
- };
59416
- }
59417
- });
59418
-
59419
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/subset.js
59420
- var require_subset2 = __commonJS({
59421
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/ranges/subset.js"(exports, module) {
59422
- init_esm_shims();
59423
- var __import____classes_range_js = __toESM(require_range3());
59424
- var __import____classes_comparator_js = __toESM(require_comparator2());
59425
- var __import____functions_satisfies_js = __toESM(require_satisfies2());
59426
- var __import____functions_compare_js = __toESM(require_compare2());
59427
- var Range = __import____classes_range_js;
59428
- var Comparator = __import____classes_comparator_js;
59429
- var { ANY } = Comparator;
59430
- var satisfies = __import____functions_satisfies_js;
59431
- var compare = __import____functions_compare_js;
59432
- var subset2 = /* @__PURE__ */ __name((sub2, dom, options = {}) => {
59433
- if (sub2 === dom) {
59434
- return true;
59435
- }
59436
- sub2 = new Range(sub2, options);
59437
- dom = new Range(dom, options);
59438
- let sawNonNull = false;
59439
- OUTER: for (const simpleSub of sub2.set) {
59440
- for (const simpleDom of dom.set) {
59441
- const isSub = simpleSubset(simpleSub, simpleDom, options);
59442
- sawNonNull = sawNonNull || isSub !== null;
59443
- if (isSub) {
59444
- continue OUTER;
59445
- }
59446
- }
59447
- if (sawNonNull) {
59448
- return false;
59449
- }
59450
- }
59451
- return true;
59452
- }, "subset");
59453
- var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
59454
- var minimumVersion = [new Comparator(">=0.0.0")];
59455
- var simpleSubset = /* @__PURE__ */ __name((sub2, dom, options) => {
59456
- if (sub2 === dom) {
59457
- return true;
59458
- }
59459
- if (sub2.length === 1 && sub2[0].semver === ANY) {
59460
- if (dom.length === 1 && dom[0].semver === ANY) {
59461
- return true;
59462
- } else if (options.includePrerelease) {
59463
- sub2 = minimumVersionWithPreRelease;
59464
- } else {
59465
- sub2 = minimumVersion;
59466
- }
59467
- }
59468
- if (dom.length === 1 && dom[0].semver === ANY) {
59469
- if (options.includePrerelease) {
59470
- return true;
59471
- } else {
59472
- dom = minimumVersion;
59473
- }
59474
- }
59475
- const eqSet = /* @__PURE__ */ new Set();
59476
- let gt2, lt2;
59477
- for (const c of sub2) {
59478
- if (c.operator === ">" || c.operator === ">=") {
59479
- gt2 = higherGT(gt2, c, options);
59480
- } else if (c.operator === "<" || c.operator === "<=") {
59481
- lt2 = lowerLT(lt2, c, options);
59482
- } else {
59483
- eqSet.add(c.semver);
59484
- }
59485
- }
59486
- if (eqSet.size > 1) {
59487
- return null;
59488
- }
59489
- let gtltComp;
59490
- if (gt2 && lt2) {
59491
- gtltComp = compare(gt2.semver, lt2.semver, options);
59492
- if (gtltComp > 0) {
59493
- return null;
59494
- } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) {
59495
- return null;
59496
- }
59497
- }
59498
- for (const eq2 of eqSet) {
59499
- if (gt2 && !satisfies(eq2, String(gt2), options)) {
59500
- return null;
59501
- }
59502
- if (lt2 && !satisfies(eq2, String(lt2), options)) {
59503
- return null;
59504
- }
59505
- for (const c of dom) {
59506
- if (!satisfies(eq2, String(c), options)) {
59507
- return false;
59508
- }
59509
- }
59510
- return true;
59511
- }
59512
- let higher, lower;
59513
- let hasDomLT, hasDomGT;
59514
- let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
59515
- let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false;
59516
- if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
59517
- needDomLTPre = false;
59518
- }
59519
- for (const c of dom) {
59520
- hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
59521
- hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
59522
- if (gt2) {
59523
- if (needDomGTPre) {
59524
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
59525
- needDomGTPre = false;
59526
- }
59527
- }
59528
- if (c.operator === ">" || c.operator === ">=") {
59529
- higher = higherGT(gt2, c, options);
59530
- if (higher === c && higher !== gt2) {
59531
- return false;
59532
- }
59533
- } else if (gt2.operator === ">=" && !satisfies(gt2.semver, String(c), options)) {
59534
- return false;
59535
- }
59536
- }
59537
- if (lt2) {
59538
- if (needDomLTPre) {
59539
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
59540
- needDomLTPre = false;
59541
- }
59542
- }
59543
- if (c.operator === "<" || c.operator === "<=") {
59544
- lower = lowerLT(lt2, c, options);
59545
- if (lower === c && lower !== lt2) {
59546
- return false;
59547
- }
59548
- } else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c), options)) {
59549
- return false;
59550
- }
59551
- }
59552
- if (!c.operator && (lt2 || gt2) && gtltComp !== 0) {
59553
- return false;
59554
- }
59555
- }
59556
- if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) {
59557
- return false;
59558
- }
59559
- if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) {
59560
- return false;
59561
- }
59562
- if (needDomGTPre || needDomLTPre) {
59563
- return false;
59564
- }
59565
- return true;
59566
- }, "simpleSubset");
59567
- var higherGT = /* @__PURE__ */ __name((a, b, options) => {
59568
- if (!a) {
59569
- return b;
59570
- }
59571
- const comp2 = compare(a.semver, b.semver, options);
59572
- return comp2 > 0 ? a : comp2 < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
59573
- }, "higherGT");
59574
- var lowerLT = /* @__PURE__ */ __name((a, b, options) => {
59575
- if (!a) {
59576
- return b;
59577
- }
59578
- const comp2 = compare(a.semver, b.semver, options);
59579
- return comp2 < 0 ? a : comp2 > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
59580
- }, "lowerLT");
59581
- module.exports = subset2;
59582
- }
59583
- });
59584
-
59585
- // ../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/index.js
59586
- var require_semver4 = __commonJS({
59587
- "../../node_modules/.pnpm/semver@7.7.1/node_modules/semver/index.js"(exports, module) {
59588
- init_esm_shims();
59589
- var __import___internal_re = __toESM(require_re2());
59590
- var __import___internal_constants = __toESM(require_constants2());
59591
- var __import___classes_semver = __toESM(require_semver3());
59592
- var __import___internal_identifiers = __toESM(require_identifiers2());
59593
- var __import___functions_parse = __toESM(require_parse3());
59594
- var __import___functions_valid = __toESM(require_valid3());
59595
- var __import___functions_clean = __toESM(require_clean2());
59596
- var __import___functions_inc = __toESM(require_inc2());
59597
- var __import___functions_diff = __toESM(require_diff2());
59598
- var __import___functions_major = __toESM(require_major2());
59599
- var __import___functions_minor = __toESM(require_minor2());
59600
- var __import___functions_patch = __toESM(require_patch2());
59601
- var __import___functions_prerelease = __toESM(require_prerelease2());
59602
- var __import___functions_compare = __toESM(require_compare2());
59603
- var __import___functions_rcompare = __toESM(require_rcompare2());
59604
- var __import___functions_compareLoose = __toESM(require_compare_loose2());
59605
- var __import___functions_compareBuild = __toESM(require_compare_build2());
59606
- var __import___functions_sort = __toESM(require_sort3());
59607
- var __import___functions_rsort = __toESM(require_rsort2());
59608
- var __import___functions_gt = __toESM(require_gt2());
59609
- var __import___functions_lt = __toESM(require_lt2());
59610
- var __import___functions_eq = __toESM(require_eq2());
59611
- var __import___functions_neq = __toESM(require_neq2());
59612
- var __import___functions_gte = __toESM(require_gte2());
59613
- var __import___functions_lte = __toESM(require_lte2());
59614
- var __import___functions_cmp = __toESM(require_cmp2());
59615
- var __import___functions_coerce = __toESM(require_coerce2());
59616
- var __import___classes_comparator = __toESM(require_comparator2());
59617
- var __import___classes_range = __toESM(require_range3());
59618
- var __import___functions_satisfies = __toESM(require_satisfies2());
59619
- var __import___ranges_toComparators = __toESM(require_to_comparators2());
59620
- var __import___ranges_maxSatisfying = __toESM(require_max_satisfying2());
59621
- var __import___ranges_minSatisfying = __toESM(require_min_satisfying2());
59622
- var __import___ranges_minVersion = __toESM(require_min_version2());
59623
- var __import___ranges_valid = __toESM(require_valid4());
59624
- var __import___ranges_outside = __toESM(require_outside2());
59625
- var __import___ranges_gtr = __toESM(require_gtr2());
59626
- var __import___ranges_ltr = __toESM(require_ltr2());
59627
- var __import___ranges_intersects = __toESM(require_intersects2());
59628
- var __import___ranges_simplify = __toESM(require_simplify2());
59629
- var __import___ranges_subset = __toESM(require_subset2());
59630
- var internalRe = __import___internal_re;
59631
- var constants = __import___internal_constants;
59632
- var SemVer = __import___classes_semver;
59633
- var identifiers = __import___internal_identifiers;
59634
- var parse2 = __import___functions_parse;
59635
- var valid2 = __import___functions_valid;
59636
- var clean = __import___functions_clean;
59637
- var inc = __import___functions_inc;
59638
- var diff = __import___functions_diff;
59639
- var major2 = __import___functions_major;
59640
- var minor = __import___functions_minor;
59641
- var patch = __import___functions_patch;
59642
- var prerelease = __import___functions_prerelease;
59643
- var compare = __import___functions_compare;
59644
- var rcompare = __import___functions_rcompare;
59645
- var compareLoose = __import___functions_compareLoose;
59646
- var compareBuild = __import___functions_compareBuild;
59647
- var sort = __import___functions_sort;
59648
- var rsort = __import___functions_rsort;
59649
- var gt2 = __import___functions_gt;
59650
- var lt2 = __import___functions_lt;
59651
- var eq2 = __import___functions_eq;
59652
- var neq = __import___functions_neq;
59653
- var gte = __import___functions_gte;
59654
- var lte = __import___functions_lte;
59655
- var cmp = __import___functions_cmp;
59656
- var coerce = __import___functions_coerce;
59657
- var Comparator = __import___classes_comparator;
59658
- var Range = __import___classes_range;
59659
- var satisfies = __import___functions_satisfies;
59660
- var toComparators = __import___ranges_toComparators;
59661
- var maxSatisfying = __import___ranges_maxSatisfying;
59662
- var minSatisfying = __import___ranges_minSatisfying;
59663
- var minVersion = __import___ranges_minVersion;
59664
- var validRange = __import___ranges_valid;
59665
- var outside = __import___ranges_outside;
59666
- var gtr = __import___ranges_gtr;
59667
- var ltr = __import___ranges_ltr;
59668
- var intersects = __import___ranges_intersects;
59669
- var simplifyRange = __import___ranges_simplify;
59670
- var subset2 = __import___ranges_subset;
59671
- module.exports = {
59672
- parse: parse2,
59673
- valid: valid2,
59674
- clean,
59675
- inc,
59676
- diff,
59677
- major: major2,
59678
- minor,
59679
- patch,
59680
- prerelease,
59681
- compare,
59682
- rcompare,
59683
- compareLoose,
59684
- compareBuild,
59685
- sort,
59686
- rsort,
59687
- gt: gt2,
59688
- lt: lt2,
59689
- eq: eq2,
59690
- neq,
59691
- gte,
59692
- lte,
59693
- cmp,
59694
- coerce,
59695
- Comparator,
59696
- Range,
59697
- satisfies,
59698
- toComparators,
59699
- maxSatisfying,
59700
- minSatisfying,
59701
- minVersion,
59702
- validRange,
59703
- outside,
59704
- gtr,
59705
- ltr,
59706
- intersects,
59707
- simplifyRange,
59708
- subset: subset2,
59709
- SemVer,
59710
- re: internalRe.re,
59711
- src: internalRe.src,
59712
- tokens: internalRe.t,
59713
- SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
59714
- RELEASE_TYPES: constants.RELEASE_TYPES,
59715
- compareIdentifiers: identifiers.compareIdentifiers,
59716
- rcompareIdentifiers: identifiers.rcompareIdentifiers
59717
- };
59718
- }
59719
- });
59720
-
59721
57680
  // ../../node_modules/.pnpm/@nx+devkit@20.8.0_nx@20.8.0_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_bd20000ef4ff80f47109509163a3e134/node_modules/@nx/devkit/src/tasks/install-packages-task.js
59722
57681
  import * as __import_child_process2 from "child_process";
59723
57682
  import * as __import_path10 from "path";
@@ -59765,7 +57724,7 @@ import * as __import_os2 from "os";
59765
57724
  var require_package_json = __commonJS({
59766
57725
  "../../node_modules/.pnpm/@nx+devkit@20.8.0_nx@20.8.0_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_bd20000ef4ff80f47109509163a3e134/node_modules/@nx/devkit/src/utils/package-json.js"(exports) {
59767
57726
  init_esm_shims();
59768
- var __import_semver = __toESM(require_semver4());
57727
+ var __import_semver = __toESM(require_semver2());
59769
57728
  var __import____tasks_installPackagesTask = __toESM(require_install_packages_task());
59770
57729
  var __import_tmp = __toESM(require_tmp2());
59771
57730
  Object.defineProperty(exports, "__esModule", { value: true });
@@ -66411,7 +64370,7 @@ var require_race = __commonJS({
66411
64370
  });
66412
64371
 
66413
64372
  // ../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/range.js
66414
- var require_range4 = __commonJS({
64373
+ var require_range3 = __commonJS({
66415
64374
  "../../node_modules/.pnpm/rxjs@7.8.1/node_modules/rxjs/dist/cjs/internal/observable/range.js"(exports) {
66416
64375
  init_esm_shims();
66417
64376
  var __import____Observable = __toESM(require_Observable());
@@ -70698,7 +68657,7 @@ var require_cjs = __commonJS({
70698
68657
  var __import___internal_observable_pairs = __toESM(require_pairs());
70699
68658
  var __import___internal_observable_partition = __toESM(require_partition());
70700
68659
  var __import___internal_observable_race = __toESM(require_race());
70701
- var __import___internal_observable_range = __toESM(require_range4());
68660
+ var __import___internal_observable_range = __toESM(require_range3());
70702
68661
  var __import___internal_observable_throwError = __toESM(require_throwError());
70703
68662
  var __import___internal_observable_timer = __toESM(require_timer2());
70704
68663
  var __import___internal_observable_using = __toESM(require_using());
@@ -71526,7 +69485,7 @@ var require_convert_nx_executor = __commonJS({
71526
69485
  "../../node_modules/.pnpm/@nx+devkit@20.8.0_nx@20.8.0_@swc-node+register@1.10.9_@swc+core@1.7.26_@swc+helpers@0.5_bd20000ef4ff80f47109509163a3e134/node_modules/@nx/devkit/src/utils/convert-nx-executor.js"(exports) {
71527
69486
  init_esm_shims();
71528
69487
  var __import___packageJson = __toESM(require_package_json());
71529
- var __import_semver = __toESM(require_semver4());
69488
+ var __import_semver = __toESM(require_semver2());
71530
69489
  var __import_rxjs = __toESM(require_cjs());
71531
69490
  Object.defineProperty(exports, "__esModule", { value: true });
71532
69491
  exports.convertNxExecutor = convertNxExecutor;
@@ -71797,16 +69756,16 @@ var {
71797
69756
  // src/commit/run.ts
71798
69757
  init_esm_shims();
71799
69758
 
71800
- // ../../node_modules/.pnpm/@inquirer+prompts@7.2.1_@types+node@22.14.0/node_modules/@inquirer/prompts/dist/esm/index.js
69759
+ // ../../node_modules/.pnpm/@inquirer+prompts@7.2.1_@types+node@22.15.3/node_modules/@inquirer/prompts/dist/esm/index.js
71801
69760
  init_esm_shims();
71802
69761
 
71803
- // ../../node_modules/.pnpm/@inquirer+checkbox@4.0.4_@types+node@22.14.0/node_modules/@inquirer/checkbox/dist/esm/index.js
69762
+ // ../../node_modules/.pnpm/@inquirer+checkbox@4.0.4_@types+node@22.15.3/node_modules/@inquirer/checkbox/dist/esm/index.js
71804
69763
  init_esm_shims();
71805
69764
 
71806
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/index.js
69765
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/index.js
71807
69766
  init_esm_shims();
71808
69767
 
71809
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/key.js
69768
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/key.js
71810
69769
  init_esm_shims();
71811
69770
  var isUpKey = /* @__PURE__ */ __name((key) => (
71812
69771
  // The up key
@@ -71825,7 +69784,7 @@ var isBackspaceKey = /* @__PURE__ */ __name((key) => key.name === "backspace", "
71825
69784
  var isNumberKey = /* @__PURE__ */ __name((key) => "123456789".includes(key.name), "isNumberKey");
71826
69785
  var isEnterKey = /* @__PURE__ */ __name((key) => key.name === "enter" || key.name === "return", "isEnterKey");
71827
69786
 
71828
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/errors.js
69787
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/errors.js
71829
69788
  init_esm_shims();
71830
69789
  var AbortPromptError = class extends Error {
71831
69790
  static {
@@ -71864,14 +69823,14 @@ var ValidationError = class extends Error {
71864
69823
  name = "ValidationError";
71865
69824
  };
71866
69825
 
71867
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
69826
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
71868
69827
  init_esm_shims();
71869
69828
  import { AsyncResource as AsyncResource2 } from "node:async_hooks";
71870
69829
 
71871
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-state.js
69830
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-state.js
71872
69831
  init_esm_shims();
71873
69832
 
71874
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/hook-engine.js
69833
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/hook-engine.js
71875
69834
  init_esm_shims();
71876
69835
  import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
71877
69836
  var hookStorage = new AsyncLocalStorage();
@@ -71986,7 +69945,7 @@ var effectScheduler = {
71986
69945
  }
71987
69946
  };
71988
69947
 
71989
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-state.js
69948
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-state.js
71990
69949
  function useState(defaultValue) {
71991
69950
  return withPointer((pointer) => {
71992
69951
  const setFn = /* @__PURE__ */ __name((newValue) => {
@@ -72011,7 +69970,7 @@ function useState(defaultValue) {
72011
69970
  }
72012
69971
  __name(useState, "useState");
72013
69972
 
72014
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-effect.js
69973
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-effect.js
72015
69974
  init_esm_shims();
72016
69975
  function useEffect(cb2, depArray) {
72017
69976
  withPointer((pointer) => {
@@ -72025,10 +69984,10 @@ function useEffect(cb2, depArray) {
72025
69984
  }
72026
69985
  __name(useEffect, "useEffect");
72027
69986
 
72028
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/make-theme.js
69987
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/make-theme.js
72029
69988
  init_esm_shims();
72030
69989
 
72031
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/theme.js
69990
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/theme.js
72032
69991
  init_esm_shims();
72033
69992
  var import_yoctocolors_cjs = __toESM(require_yoctocolors_cjs(), 1);
72034
69993
 
@@ -72326,7 +70285,7 @@ var figures = shouldUseMain ? mainSymbols : fallbackSymbols;
72326
70285
  var esm_default = figures;
72327
70286
  var replacements = Object.entries(specialMainSymbols);
72328
70287
 
72329
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/theme.js
70288
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/theme.js
72330
70289
  var defaultTheme = {
72331
70290
  prefix: {
72332
70291
  idle: import_yoctocolors_cjs.default.blue("?"),
@@ -72359,7 +70318,7 @@ var defaultTheme = {
72359
70318
  }
72360
70319
  };
72361
70320
 
72362
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/make-theme.js
70321
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/make-theme.js
72363
70322
  function isPlainObject(value) {
72364
70323
  if (typeof value !== "object" || value === null) return false;
72365
70324
  let proto2 = value;
@@ -72389,7 +70348,7 @@ function makeTheme(...themes) {
72389
70348
  }
72390
70349
  __name(makeTheme, "makeTheme");
72391
70350
 
72392
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
70351
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-prefix.js
72393
70352
  function usePrefix({ status = "idle", theme }) {
72394
70353
  const [showLoader, setShowLoader] = useState(false);
72395
70354
  const [tick, setTick] = useState(0);
@@ -72423,7 +70382,7 @@ function usePrefix({ status = "idle", theme }) {
72423
70382
  }
72424
70383
  __name(usePrefix, "usePrefix");
72425
70384
 
72426
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-memo.js
70385
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-memo.js
72427
70386
  init_esm_shims();
72428
70387
  function useMemo(fn, dependencies) {
72429
70388
  return withPointer((pointer) => {
@@ -72441,7 +70400,7 @@ function useMemo(fn, dependencies) {
72441
70400
  }
72442
70401
  __name(useMemo, "useMemo");
72443
70402
 
72444
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-ref.js
70403
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-ref.js
72445
70404
  init_esm_shims();
72446
70405
  function useRef(val) {
72447
70406
  return useState({
@@ -72450,7 +70409,7 @@ function useRef(val) {
72450
70409
  }
72451
70410
  __name(useRef, "useRef");
72452
70411
 
72453
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/use-keypress.js
70412
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/use-keypress.js
72454
70413
  init_esm_shims();
72455
70414
  function useKeypress(userHandler) {
72456
70415
  const signal = useRef(userHandler);
@@ -72470,10 +70429,10 @@ function useKeypress(userHandler) {
72470
70429
  }
72471
70430
  __name(useKeypress, "useKeypress");
72472
70431
 
72473
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/pagination/use-pagination.js
70432
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/pagination/use-pagination.js
72474
70433
  init_esm_shims();
72475
70434
 
72476
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/utils.js
70435
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/utils.js
72477
70436
  init_esm_shims();
72478
70437
  var import_cli_width = __toESM(require_cli_width(), 1);
72479
70438
  var import_wrap_ansi = __toESM(require_wrap_ansi(), 1);
@@ -72492,7 +70451,7 @@ function readlineWidth() {
72492
70451
  }
72493
70452
  __name(readlineWidth, "readlineWidth");
72494
70453
 
72495
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/pagination/lines.js
70454
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/pagination/lines.js
72496
70455
  init_esm_shims();
72497
70456
  function split(content, width) {
72498
70457
  return breakLines(content, width).split("\n");
@@ -72543,7 +70502,7 @@ function lines({ items, width, renderItem, active, position: requested, pageSize
72543
70502
  }
72544
70503
  __name(lines, "lines");
72545
70504
 
72546
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/pagination/position.js
70505
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/pagination/position.js
72547
70506
  init_esm_shims();
72548
70507
  function finite({ active, pageSize, total }) {
72549
70508
  const middle = Math.floor(pageSize / 2);
@@ -72561,7 +70520,7 @@ function infinite({ active, lastActive, total, pageSize, pointer }) {
72561
70520
  }
72562
70521
  __name(infinite, "infinite");
72563
70522
 
72564
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/pagination/use-pagination.js
70523
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/pagination/use-pagination.js
72565
70524
  function usePagination({ items, active, renderItem, pageSize, loop = true }) {
72566
70525
  const state = useRef({
72567
70526
  position: 0,
@@ -72591,7 +70550,7 @@ function usePagination({ items, active, renderItem, pageSize, loop = true }) {
72591
70550
  }
72592
70551
  __name(usePagination, "usePagination");
72593
70552
 
72594
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
70553
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
72595
70554
  init_esm_shims();
72596
70555
  var import_mute_stream = __toESM(require_lib(), 1);
72597
70556
  import * as readline2 from "node:readline";
@@ -72848,7 +70807,7 @@ var {
72848
70807
  unload
72849
70808
  } = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback());
72850
70809
 
72851
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
70810
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/screen-manager.js
72852
70811
  init_esm_shims();
72853
70812
  var import_strip_ansi = __toESM(require_strip_ansi(), 1);
72854
70813
  var import_ansi_escapes = __toESM(require_ansi_escapes(), 1);
@@ -72918,7 +70877,7 @@ var ScreenManager = class {
72918
70877
  }
72919
70878
  };
72920
70879
 
72921
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/promise-polyfill.js
70880
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/promise-polyfill.js
72922
70881
  init_esm_shims();
72923
70882
  var PromisePolyfill = class extends Promise {
72924
70883
  static {
@@ -72941,7 +70900,7 @@ var PromisePolyfill = class extends Promise {
72941
70900
  }
72942
70901
  };
72943
70902
 
72944
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
70903
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/create-prompt.js
72945
70904
  function getCallSites() {
72946
70905
  const _prepareStackTrace = Error.prepareStackTrace;
72947
70906
  try {
@@ -73036,7 +70995,7 @@ function createPrompt(view) {
73036
70995
  }
73037
70996
  __name(createPrompt, "createPrompt");
73038
70997
 
73039
- // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.14.0/node_modules/@inquirer/core/dist/esm/lib/Separator.js
70998
+ // ../../node_modules/.pnpm/@inquirer+core@10.1.2_@types+node@22.15.3/node_modules/@inquirer/core/dist/esm/lib/Separator.js
73040
70999
  init_esm_shims();
73041
71000
  var import_yoctocolors_cjs2 = __toESM(require_yoctocolors_cjs(), 1);
73042
71001
  var Separator = class {
@@ -73057,7 +71016,7 @@ var Separator = class {
73057
71016
  }
73058
71017
  };
73059
71018
 
73060
- // ../../node_modules/.pnpm/@inquirer+checkbox@4.0.4_@types+node@22.14.0/node_modules/@inquirer/checkbox/dist/esm/index.js
71019
+ // ../../node_modules/.pnpm/@inquirer+checkbox@4.0.4_@types+node@22.15.3/node_modules/@inquirer/checkbox/dist/esm/index.js
73061
71020
  var import_yoctocolors_cjs3 = __toESM(require_yoctocolors_cjs(), 1);
73062
71021
  var import_ansi_escapes2 = __toESM(require_ansi_escapes(), 1);
73063
71022
  var checkboxTheme = {
@@ -73249,7 +71208,7 @@ ${theme.style.error(errorMsg)}`;
73249
71208
  ${page}${helpTipBottom}${choiceDescription}${error}${import_ansi_escapes2.default.cursorHide}`;
73250
71209
  });
73251
71210
 
73252
- // ../../node_modules/.pnpm/@inquirer+editor@4.2.1_@types+node@22.14.0/node_modules/@inquirer/editor/dist/esm/index.js
71211
+ // ../../node_modules/.pnpm/@inquirer+editor@4.2.1_@types+node@22.15.3/node_modules/@inquirer/editor/dist/esm/index.js
73253
71212
  init_esm_shims();
73254
71213
  var import_external_editor = __toESM(require_main(), 1);
73255
71214
  import { AsyncResource as AsyncResource4 } from "node:async_hooks";
@@ -73331,7 +71290,7 @@ var esm_default3 = createPrompt((config, done) => {
73331
71290
  ];
73332
71291
  });
73333
71292
 
73334
- // ../../node_modules/.pnpm/@inquirer+confirm@5.1.1_@types+node@22.14.0/node_modules/@inquirer/confirm/dist/esm/index.js
71293
+ // ../../node_modules/.pnpm/@inquirer+confirm@5.1.1_@types+node@22.15.3/node_modules/@inquirer/confirm/dist/esm/index.js
73335
71294
  init_esm_shims();
73336
71295
  function getBooleanValue(value, defaultValue) {
73337
71296
  let answer = defaultValue !== false;
@@ -73379,7 +71338,7 @@ var esm_default4 = createPrompt((config, done) => {
73379
71338
  return `${prefix} ${message2}${defaultValue} ${formattedValue}`;
73380
71339
  });
73381
71340
 
73382
- // ../../node_modules/.pnpm/@inquirer+input@4.1.1_@types+node@22.14.0/node_modules/@inquirer/input/dist/esm/index.js
71341
+ // ../../node_modules/.pnpm/@inquirer+input@4.1.1_@types+node@22.15.3/node_modules/@inquirer/input/dist/esm/index.js
73383
71342
  init_esm_shims();
73384
71343
  var inputTheme = {
73385
71344
  validationFailureMode: "keep"
@@ -73456,7 +71415,7 @@ var esm_default5 = createPrompt((config, done) => {
73456
71415
  ];
73457
71416
  });
73458
71417
 
73459
- // ../../node_modules/.pnpm/@inquirer+number@3.0.4_@types+node@22.14.0/node_modules/@inquirer/number/dist/esm/index.js
71418
+ // ../../node_modules/.pnpm/@inquirer+number@3.0.4_@types+node@22.15.3/node_modules/@inquirer/number/dist/esm/index.js
73460
71419
  init_esm_shims();
73461
71420
  function isStepOf(value, step, min2) {
73462
71421
  const valuePow = value * Math.pow(10, 6);
@@ -73556,7 +71515,7 @@ var esm_default6 = createPrompt((config, done) => {
73556
71515
  ];
73557
71516
  });
73558
71517
 
73559
- // ../../node_modules/.pnpm/@inquirer+expand@4.0.4_@types+node@22.14.0/node_modules/@inquirer/expand/dist/esm/index.js
71518
+ // ../../node_modules/.pnpm/@inquirer+expand@4.0.4_@types+node@22.15.3/node_modules/@inquirer/expand/dist/esm/index.js
73560
71519
  init_esm_shims();
73561
71520
  var import_yoctocolors_cjs4 = __toESM(require_yoctocolors_cjs(), 1);
73562
71521
  function normalizeChoices2(choices) {
@@ -73665,7 +71624,7 @@ var esm_default7 = createPrompt((config, done) => {
73665
71624
  ];
73666
71625
  });
73667
71626
 
73668
- // ../../node_modules/.pnpm/@inquirer+rawlist@4.0.4_@types+node@22.14.0/node_modules/@inquirer/rawlist/dist/esm/index.js
71627
+ // ../../node_modules/.pnpm/@inquirer+rawlist@4.0.4_@types+node@22.15.3/node_modules/@inquirer/rawlist/dist/esm/index.js
73669
71628
  init_esm_shims();
73670
71629
  var import_yoctocolors_cjs5 = __toESM(require_yoctocolors_cjs(), 1);
73671
71630
  var numberRegex = /\d+/;
@@ -73758,7 +71717,7 @@ var esm_default8 = createPrompt((config, done) => {
73758
71717
  ];
73759
71718
  });
73760
71719
 
73761
- // ../../node_modules/.pnpm/@inquirer+password@4.0.4_@types+node@22.14.0/node_modules/@inquirer/password/dist/esm/index.js
71720
+ // ../../node_modules/.pnpm/@inquirer+password@4.0.4_@types+node@22.15.3/node_modules/@inquirer/password/dist/esm/index.js
73762
71721
  init_esm_shims();
73763
71722
  var import_ansi_escapes3 = __toESM(require_ansi_escapes(), 1);
73764
71723
  var esm_default9 = createPrompt((config, done) => {
@@ -73819,7 +71778,7 @@ var esm_default9 = createPrompt((config, done) => {
73819
71778
  ];
73820
71779
  });
73821
71780
 
73822
- // ../../node_modules/.pnpm/@inquirer+search@3.0.4_@types+node@22.14.0/node_modules/@inquirer/search/dist/esm/index.js
71781
+ // ../../node_modules/.pnpm/@inquirer+search@3.0.4_@types+node@22.15.3/node_modules/@inquirer/search/dist/esm/index.js
73823
71782
  init_esm_shims();
73824
71783
  var import_yoctocolors_cjs6 = __toESM(require_yoctocolors_cjs(), 1);
73825
71784
  var searchTheme = {
@@ -74000,7 +71959,7 @@ ${theme.style.description(selectedChoice.description)}` : ``;
74000
71959
  ];
74001
71960
  });
74002
71961
 
74003
- // ../../node_modules/.pnpm/@inquirer+select@4.0.4_@types+node@22.14.0/node_modules/@inquirer/select/dist/esm/index.js
71962
+ // ../../node_modules/.pnpm/@inquirer+select@4.0.4_@types+node@22.15.3/node_modules/@inquirer/select/dist/esm/index.js
74004
71963
  init_esm_shims();
74005
71964
  var import_yoctocolors_cjs7 = __toESM(require_yoctocolors_cjs(), 1);
74006
71965
  var import_ansi_escapes4 = __toESM(require_ansi_escapes(), 1);