publish-microfrontend 1.11.2 → 1.12.0-beta.a0009f0

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 (2) hide show
  1. package/lib/index.js +1956 -304
  2. package/package.json +2 -2
package/lib/index.js CHANGED
@@ -439,7 +439,7 @@ var require_yargs_parser = __commonJS({
439
439
  var decamelize = require_decamelize();
440
440
  var path = require("path");
441
441
  var tokenizeArgString = require_tokenize_arg_string();
442
- var util3 = require("util");
442
+ var util4 = require("util");
443
443
  function parse(args2, opts) {
444
444
  opts = Object.assign(/* @__PURE__ */ Object.create(null), opts);
445
445
  args2 = tokenizeArgString(args2);
@@ -470,7 +470,7 @@ var require_yargs_parser = __commonJS({
470
470
  const notFlagsArgv = notFlagsOption ? "--" : "_";
471
471
  const newAliases = /* @__PURE__ */ Object.create(null);
472
472
  const defaulted = /* @__PURE__ */ Object.create(null);
473
- const __ = opts.__ || util3.format;
473
+ const __ = opts.__ || util4.format;
474
474
  const flags = {
475
475
  aliases: /* @__PURE__ */ Object.create(null),
476
476
  arrays: /* @__PURE__ */ Object.create(null),
@@ -4288,7 +4288,7 @@ var require_y18n = __commonJS({
4288
4288
  "node_modules/y18n/index.js"(exports2, module2) {
4289
4289
  var fs = require("fs");
4290
4290
  var path = require("path");
4291
- var util3 = require("util");
4291
+ var util4 = require("util");
4292
4292
  function Y18N(opts) {
4293
4293
  opts = opts || {};
4294
4294
  this.directory = opts.directory || "./locales";
@@ -4316,7 +4316,7 @@ var require_y18n = __commonJS({
4316
4316
  } else {
4317
4317
  cb();
4318
4318
  }
4319
- return util3.format.apply(util3, [this.cache[this.locale][str] || str].concat(args2));
4319
+ return util4.format.apply(util4, [this.cache[this.locale][str] || str].concat(args2));
4320
4320
  };
4321
4321
  Y18N.prototype._taggedLiteral = function(parts) {
4322
4322
  var args2 = arguments;
@@ -4401,7 +4401,7 @@ var require_y18n = __commonJS({
4401
4401
  }
4402
4402
  var values = [str];
4403
4403
  if (~str.indexOf("%d")) values.push(quantity);
4404
- return util3.format.apply(util3, values.concat(args2));
4404
+ return util4.format.apply(util4, values.concat(args2));
4405
4405
  };
4406
4406
  Y18N.prototype.setLocale = function(locale) {
4407
4407
  this.locale = locale;
@@ -9239,13 +9239,13 @@ var require_inherits_browser = __commonJS({
9239
9239
  var require_inherits = __commonJS({
9240
9240
  "../../../node_modules/inherits/inherits.js"(exports2, module2) {
9241
9241
  try {
9242
- util3 = require("util");
9243
- if (typeof util3.inherits !== "function") throw "";
9244
- module2.exports = util3.inherits;
9242
+ util4 = require("util");
9243
+ if (typeof util4.inherits !== "function") throw "";
9244
+ module2.exports = util4.inherits;
9245
9245
  } catch (e) {
9246
9246
  module2.exports = require_inherits_browser();
9247
9247
  }
9248
- var util3;
9248
+ var util4;
9249
9249
  }
9250
9250
  });
9251
9251
 
@@ -9456,7 +9456,7 @@ var require_sync = __commonJS({
9456
9456
  var minimatch = require_minimatch();
9457
9457
  var Minimatch = minimatch.Minimatch;
9458
9458
  var Glob = require_glob().Glob;
9459
- var util3 = require("util");
9459
+ var util4 = require("util");
9460
9460
  var path = require("path");
9461
9461
  var assert = require("assert");
9462
9462
  var isAbsolute = require("path").isAbsolute;
@@ -9939,7 +9939,7 @@ var require_glob = __commonJS({
9939
9939
  var setopts = common.setopts;
9940
9940
  var ownProp = common.ownProp;
9941
9941
  var inflight = require_inflight();
9942
- var util3 = require("util");
9942
+ var util4 = require("util");
9943
9943
  var childrenIgnored = common.childrenIgnored;
9944
9944
  var isIgnored = common.isIgnored;
9945
9945
  var once = require_once();
@@ -10482,7 +10482,7 @@ var require_glob = __commonJS({
10482
10482
  var require_delayed_stream = __commonJS({
10483
10483
  "../../../node_modules/delayed-stream/lib/delayed_stream.js"(exports2, module2) {
10484
10484
  var Stream = require("stream").Stream;
10485
- var util3 = require("util");
10485
+ var util4 = require("util");
10486
10486
  module2.exports = DelayedStream;
10487
10487
  function DelayedStream() {
10488
10488
  this.source = null;
@@ -10493,7 +10493,7 @@ var require_delayed_stream = __commonJS({
10493
10493
  this._released = false;
10494
10494
  this._bufferedEvents = [];
10495
10495
  }
10496
- util3.inherits(DelayedStream, Stream);
10496
+ util4.inherits(DelayedStream, Stream);
10497
10497
  DelayedStream.create = function(source, options) {
10498
10498
  var delayedStream = new this();
10499
10499
  options = options || {};
@@ -10572,7 +10572,7 @@ var require_delayed_stream = __commonJS({
10572
10572
  // ../../../node_modules/combined-stream/lib/combined_stream.js
10573
10573
  var require_combined_stream = __commonJS({
10574
10574
  "../../../node_modules/combined-stream/lib/combined_stream.js"(exports2, module2) {
10575
- var util3 = require("util");
10575
+ var util4 = require("util");
10576
10576
  var Stream = require("stream").Stream;
10577
10577
  var DelayedStream = require_delayed_stream();
10578
10578
  module2.exports = CombinedStream;
@@ -10588,7 +10588,7 @@ var require_combined_stream = __commonJS({
10588
10588
  this._insideLoop = false;
10589
10589
  this._pendingNext = false;
10590
10590
  }
10591
- util3.inherits(CombinedStream, Stream);
10591
+ util4.inherits(CombinedStream, Stream);
10592
10592
  CombinedStream.create = function(options) {
10593
10593
  var combinedStream = new this();
10594
10594
  options = options || {};
@@ -20433,7 +20433,7 @@ var require_form_data = __commonJS({
20433
20433
  "../../../node_modules/form-data/lib/form_data.js"(exports2, module2) {
20434
20434
  "use strict";
20435
20435
  var CombinedStream = require_combined_stream();
20436
- var util3 = require("util");
20436
+ var util4 = require("util");
20437
20437
  var path = require("path");
20438
20438
  var http3 = require("http");
20439
20439
  var https2 = require("https");
@@ -20462,7 +20462,7 @@ var require_form_data = __commonJS({
20462
20462
  this[option] = options[option];
20463
20463
  }
20464
20464
  }
20465
- util3.inherits(FormData4, CombinedStream);
20465
+ util4.inherits(FormData4, CombinedStream);
20466
20466
  FormData4.LINE_BREAK = "\r\n";
20467
20467
  FormData4.DEFAULT_CONTENT_TYPE = "application/octet-stream";
20468
20468
  FormData4.prototype.append = function(field, value, options) {
@@ -20750,8 +20750,1221 @@ var require_form_data = __commonJS({
20750
20750
  }
20751
20751
  });
20752
20752
 
20753
+ // ../../../node_modules/ms/index.js
20754
+ var require_ms = __commonJS({
20755
+ "../../../node_modules/ms/index.js"(exports2, module2) {
20756
+ var s = 1e3;
20757
+ var m = s * 60;
20758
+ var h = m * 60;
20759
+ var d = h * 24;
20760
+ var w = d * 7;
20761
+ var y = d * 365.25;
20762
+ module2.exports = function(val, options) {
20763
+ options = options || {};
20764
+ var type = typeof val;
20765
+ if (type === "string" && val.length > 0) {
20766
+ return parse(val);
20767
+ } else if (type === "number" && isFinite(val)) {
20768
+ return options.long ? fmtLong(val) : fmtShort(val);
20769
+ }
20770
+ throw new Error(
20771
+ "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
20772
+ );
20773
+ };
20774
+ function parse(str) {
20775
+ str = String(str);
20776
+ if (str.length > 100) {
20777
+ return;
20778
+ }
20779
+ var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
20780
+ str
20781
+ );
20782
+ if (!match) {
20783
+ return;
20784
+ }
20785
+ var n = parseFloat(match[1]);
20786
+ var type = (match[2] || "ms").toLowerCase();
20787
+ switch (type) {
20788
+ case "years":
20789
+ case "year":
20790
+ case "yrs":
20791
+ case "yr":
20792
+ case "y":
20793
+ return n * y;
20794
+ case "weeks":
20795
+ case "week":
20796
+ case "w":
20797
+ return n * w;
20798
+ case "days":
20799
+ case "day":
20800
+ case "d":
20801
+ return n * d;
20802
+ case "hours":
20803
+ case "hour":
20804
+ case "hrs":
20805
+ case "hr":
20806
+ case "h":
20807
+ return n * h;
20808
+ case "minutes":
20809
+ case "minute":
20810
+ case "mins":
20811
+ case "min":
20812
+ case "m":
20813
+ return n * m;
20814
+ case "seconds":
20815
+ case "second":
20816
+ case "secs":
20817
+ case "sec":
20818
+ case "s":
20819
+ return n * s;
20820
+ case "milliseconds":
20821
+ case "millisecond":
20822
+ case "msecs":
20823
+ case "msec":
20824
+ case "ms":
20825
+ return n;
20826
+ default:
20827
+ return void 0;
20828
+ }
20829
+ }
20830
+ function fmtShort(ms) {
20831
+ var msAbs = Math.abs(ms);
20832
+ if (msAbs >= d) {
20833
+ return Math.round(ms / d) + "d";
20834
+ }
20835
+ if (msAbs >= h) {
20836
+ return Math.round(ms / h) + "h";
20837
+ }
20838
+ if (msAbs >= m) {
20839
+ return Math.round(ms / m) + "m";
20840
+ }
20841
+ if (msAbs >= s) {
20842
+ return Math.round(ms / s) + "s";
20843
+ }
20844
+ return ms + "ms";
20845
+ }
20846
+ function fmtLong(ms) {
20847
+ var msAbs = Math.abs(ms);
20848
+ if (msAbs >= d) {
20849
+ return plural(ms, msAbs, d, "day");
20850
+ }
20851
+ if (msAbs >= h) {
20852
+ return plural(ms, msAbs, h, "hour");
20853
+ }
20854
+ if (msAbs >= m) {
20855
+ return plural(ms, msAbs, m, "minute");
20856
+ }
20857
+ if (msAbs >= s) {
20858
+ return plural(ms, msAbs, s, "second");
20859
+ }
20860
+ return ms + " ms";
20861
+ }
20862
+ function plural(ms, msAbs, n, name) {
20863
+ var isPlural = msAbs >= n * 1.5;
20864
+ return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
20865
+ }
20866
+ }
20867
+ });
20868
+
20869
+ // ../../../node_modules/axios/node_modules/debug/src/common.js
20870
+ var require_common2 = __commonJS({
20871
+ "../../../node_modules/axios/node_modules/debug/src/common.js"(exports2, module2) {
20872
+ function setup(env3) {
20873
+ createDebug.debug = createDebug;
20874
+ createDebug.default = createDebug;
20875
+ createDebug.coerce = coerce;
20876
+ createDebug.disable = disable;
20877
+ createDebug.enable = enable;
20878
+ createDebug.enabled = enabled;
20879
+ createDebug.humanize = require_ms();
20880
+ createDebug.destroy = destroy;
20881
+ Object.keys(env3).forEach((key) => {
20882
+ createDebug[key] = env3[key];
20883
+ });
20884
+ createDebug.names = [];
20885
+ createDebug.skips = [];
20886
+ createDebug.formatters = {};
20887
+ function selectColor(namespace) {
20888
+ let hash = 0;
20889
+ for (let i = 0; i < namespace.length; i++) {
20890
+ hash = (hash << 5) - hash + namespace.charCodeAt(i);
20891
+ hash |= 0;
20892
+ }
20893
+ return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
20894
+ }
20895
+ createDebug.selectColor = selectColor;
20896
+ function createDebug(namespace) {
20897
+ let prevTime;
20898
+ let enableOverride = null;
20899
+ let namespacesCache;
20900
+ let enabledCache;
20901
+ function debug(...args2) {
20902
+ if (!debug.enabled) {
20903
+ return;
20904
+ }
20905
+ const self2 = debug;
20906
+ const curr = Number(/* @__PURE__ */ new Date());
20907
+ const ms = curr - (prevTime || curr);
20908
+ self2.diff = ms;
20909
+ self2.prev = prevTime;
20910
+ self2.curr = curr;
20911
+ prevTime = curr;
20912
+ args2[0] = createDebug.coerce(args2[0]);
20913
+ if (typeof args2[0] !== "string") {
20914
+ args2.unshift("%O");
20915
+ }
20916
+ let index = 0;
20917
+ args2[0] = args2[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
20918
+ if (match === "%%") {
20919
+ return "%";
20920
+ }
20921
+ index++;
20922
+ const formatter = createDebug.formatters[format2];
20923
+ if (typeof formatter === "function") {
20924
+ const val = args2[index];
20925
+ match = formatter.call(self2, val);
20926
+ args2.splice(index, 1);
20927
+ index--;
20928
+ }
20929
+ return match;
20930
+ });
20931
+ createDebug.formatArgs.call(self2, args2);
20932
+ const logFn = self2.log || createDebug.log;
20933
+ logFn.apply(self2, args2);
20934
+ }
20935
+ debug.namespace = namespace;
20936
+ debug.useColors = createDebug.useColors();
20937
+ debug.color = createDebug.selectColor(namespace);
20938
+ debug.extend = extend2;
20939
+ debug.destroy = createDebug.destroy;
20940
+ Object.defineProperty(debug, "enabled", {
20941
+ enumerable: true,
20942
+ configurable: false,
20943
+ get: () => {
20944
+ if (enableOverride !== null) {
20945
+ return enableOverride;
20946
+ }
20947
+ if (namespacesCache !== createDebug.namespaces) {
20948
+ namespacesCache = createDebug.namespaces;
20949
+ enabledCache = createDebug.enabled(namespace);
20950
+ }
20951
+ return enabledCache;
20952
+ },
20953
+ set: (v) => {
20954
+ enableOverride = v;
20955
+ }
20956
+ });
20957
+ if (typeof createDebug.init === "function") {
20958
+ createDebug.init(debug);
20959
+ }
20960
+ return debug;
20961
+ }
20962
+ function extend2(namespace, delimiter) {
20963
+ const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
20964
+ newDebug.log = this.log;
20965
+ return newDebug;
20966
+ }
20967
+ function enable(namespaces) {
20968
+ createDebug.save(namespaces);
20969
+ createDebug.namespaces = namespaces;
20970
+ createDebug.names = [];
20971
+ createDebug.skips = [];
20972
+ const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
20973
+ for (const ns of split) {
20974
+ if (ns[0] === "-") {
20975
+ createDebug.skips.push(ns.slice(1));
20976
+ } else {
20977
+ createDebug.names.push(ns);
20978
+ }
20979
+ }
20980
+ }
20981
+ function matchesTemplate(search, template) {
20982
+ let searchIndex = 0;
20983
+ let templateIndex = 0;
20984
+ let starIndex = -1;
20985
+ let matchIndex = 0;
20986
+ while (searchIndex < search.length) {
20987
+ if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
20988
+ if (template[templateIndex] === "*") {
20989
+ starIndex = templateIndex;
20990
+ matchIndex = searchIndex;
20991
+ templateIndex++;
20992
+ } else {
20993
+ searchIndex++;
20994
+ templateIndex++;
20995
+ }
20996
+ } else if (starIndex !== -1) {
20997
+ templateIndex = starIndex + 1;
20998
+ matchIndex++;
20999
+ searchIndex = matchIndex;
21000
+ } else {
21001
+ return false;
21002
+ }
21003
+ }
21004
+ while (templateIndex < template.length && template[templateIndex] === "*") {
21005
+ templateIndex++;
21006
+ }
21007
+ return templateIndex === template.length;
21008
+ }
21009
+ function disable() {
21010
+ const namespaces = [
21011
+ ...createDebug.names,
21012
+ ...createDebug.skips.map((namespace) => "-" + namespace)
21013
+ ].join(",");
21014
+ createDebug.enable("");
21015
+ return namespaces;
21016
+ }
21017
+ function enabled(name) {
21018
+ for (const skip of createDebug.skips) {
21019
+ if (matchesTemplate(name, skip)) {
21020
+ return false;
21021
+ }
21022
+ }
21023
+ for (const ns of createDebug.names) {
21024
+ if (matchesTemplate(name, ns)) {
21025
+ return true;
21026
+ }
21027
+ }
21028
+ return false;
21029
+ }
21030
+ function coerce(val) {
21031
+ if (val instanceof Error) {
21032
+ return val.stack || val.message;
21033
+ }
21034
+ return val;
21035
+ }
21036
+ function destroy() {
21037
+ console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
21038
+ }
21039
+ createDebug.enable(createDebug.load());
21040
+ return createDebug;
21041
+ }
21042
+ module2.exports = setup;
21043
+ }
21044
+ });
21045
+
21046
+ // ../../../node_modules/axios/node_modules/debug/src/browser.js
21047
+ var require_browser = __commonJS({
21048
+ "../../../node_modules/axios/node_modules/debug/src/browser.js"(exports2, module2) {
21049
+ exports2.formatArgs = formatArgs;
21050
+ exports2.save = save;
21051
+ exports2.load = load2;
21052
+ exports2.useColors = useColors;
21053
+ exports2.storage = localstorage();
21054
+ exports2.destroy = /* @__PURE__ */ (() => {
21055
+ let warned = false;
21056
+ return () => {
21057
+ if (!warned) {
21058
+ warned = true;
21059
+ console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
21060
+ }
21061
+ };
21062
+ })();
21063
+ exports2.colors = [
21064
+ "#0000CC",
21065
+ "#0000FF",
21066
+ "#0033CC",
21067
+ "#0033FF",
21068
+ "#0066CC",
21069
+ "#0066FF",
21070
+ "#0099CC",
21071
+ "#0099FF",
21072
+ "#00CC00",
21073
+ "#00CC33",
21074
+ "#00CC66",
21075
+ "#00CC99",
21076
+ "#00CCCC",
21077
+ "#00CCFF",
21078
+ "#3300CC",
21079
+ "#3300FF",
21080
+ "#3333CC",
21081
+ "#3333FF",
21082
+ "#3366CC",
21083
+ "#3366FF",
21084
+ "#3399CC",
21085
+ "#3399FF",
21086
+ "#33CC00",
21087
+ "#33CC33",
21088
+ "#33CC66",
21089
+ "#33CC99",
21090
+ "#33CCCC",
21091
+ "#33CCFF",
21092
+ "#6600CC",
21093
+ "#6600FF",
21094
+ "#6633CC",
21095
+ "#6633FF",
21096
+ "#66CC00",
21097
+ "#66CC33",
21098
+ "#9900CC",
21099
+ "#9900FF",
21100
+ "#9933CC",
21101
+ "#9933FF",
21102
+ "#99CC00",
21103
+ "#99CC33",
21104
+ "#CC0000",
21105
+ "#CC0033",
21106
+ "#CC0066",
21107
+ "#CC0099",
21108
+ "#CC00CC",
21109
+ "#CC00FF",
21110
+ "#CC3300",
21111
+ "#CC3333",
21112
+ "#CC3366",
21113
+ "#CC3399",
21114
+ "#CC33CC",
21115
+ "#CC33FF",
21116
+ "#CC6600",
21117
+ "#CC6633",
21118
+ "#CC9900",
21119
+ "#CC9933",
21120
+ "#CCCC00",
21121
+ "#CCCC33",
21122
+ "#FF0000",
21123
+ "#FF0033",
21124
+ "#FF0066",
21125
+ "#FF0099",
21126
+ "#FF00CC",
21127
+ "#FF00FF",
21128
+ "#FF3300",
21129
+ "#FF3333",
21130
+ "#FF3366",
21131
+ "#FF3399",
21132
+ "#FF33CC",
21133
+ "#FF33FF",
21134
+ "#FF6600",
21135
+ "#FF6633",
21136
+ "#FF9900",
21137
+ "#FF9933",
21138
+ "#FFCC00",
21139
+ "#FFCC33"
21140
+ ];
21141
+ function useColors() {
21142
+ if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
21143
+ return true;
21144
+ }
21145
+ if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
21146
+ return false;
21147
+ }
21148
+ let m;
21149
+ return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
21150
+ typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
21151
+ // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
21152
+ typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
21153
+ typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
21154
+ }
21155
+ function formatArgs(args2) {
21156
+ args2[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args2[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
21157
+ if (!this.useColors) {
21158
+ return;
21159
+ }
21160
+ const c = "color: " + this.color;
21161
+ args2.splice(1, 0, c, "color: inherit");
21162
+ let index = 0;
21163
+ let lastC = 0;
21164
+ args2[0].replace(/%[a-zA-Z%]/g, (match) => {
21165
+ if (match === "%%") {
21166
+ return;
21167
+ }
21168
+ index++;
21169
+ if (match === "%c") {
21170
+ lastC = index;
21171
+ }
21172
+ });
21173
+ args2.splice(lastC, 0, c);
21174
+ }
21175
+ exports2.log = console.debug || console.log || (() => {
21176
+ });
21177
+ function save(namespaces) {
21178
+ try {
21179
+ if (namespaces) {
21180
+ exports2.storage.setItem("debug", namespaces);
21181
+ } else {
21182
+ exports2.storage.removeItem("debug");
21183
+ }
21184
+ } catch (error) {
21185
+ }
21186
+ }
21187
+ function load2() {
21188
+ let r;
21189
+ try {
21190
+ r = exports2.storage.getItem("debug") || exports2.storage.getItem("DEBUG");
21191
+ } catch (error) {
21192
+ }
21193
+ if (!r && typeof process !== "undefined" && "env" in process) {
21194
+ r = process.env.DEBUG;
21195
+ }
21196
+ return r;
21197
+ }
21198
+ function localstorage() {
21199
+ try {
21200
+ return localStorage;
21201
+ } catch (error) {
21202
+ }
21203
+ }
21204
+ module2.exports = require_common2()(exports2);
21205
+ var { formatters } = module2.exports;
21206
+ formatters.j = function(v) {
21207
+ try {
21208
+ return JSON.stringify(v);
21209
+ } catch (error) {
21210
+ return "[UnexpectedJSONParseError]: " + error.message;
21211
+ }
21212
+ };
21213
+ }
21214
+ });
21215
+
21216
+ // ../../../node_modules/has-flag/index.js
21217
+ var require_has_flag = __commonJS({
21218
+ "../../../node_modules/has-flag/index.js"(exports2, module2) {
21219
+ "use strict";
21220
+ module2.exports = (flag, argv = process.argv) => {
21221
+ const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
21222
+ const position = argv.indexOf(prefix + flag);
21223
+ const terminatorPosition = argv.indexOf("--");
21224
+ return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
21225
+ };
21226
+ }
21227
+ });
21228
+
21229
+ // ../../../node_modules/supports-color/index.js
21230
+ var require_supports_color = __commonJS({
21231
+ "../../../node_modules/supports-color/index.js"(exports2, module2) {
21232
+ "use strict";
21233
+ var os4 = require("os");
21234
+ var tty3 = require("tty");
21235
+ var hasFlag3 = require_has_flag();
21236
+ var { env: env3 } = process;
21237
+ var forceColor;
21238
+ if (hasFlag3("no-color") || hasFlag3("no-colors") || hasFlag3("color=false") || hasFlag3("color=never")) {
21239
+ forceColor = 0;
21240
+ } else if (hasFlag3("color") || hasFlag3("colors") || hasFlag3("color=true") || hasFlag3("color=always")) {
21241
+ forceColor = 1;
21242
+ }
21243
+ if ("FORCE_COLOR" in env3) {
21244
+ if (env3.FORCE_COLOR === "true") {
21245
+ forceColor = 1;
21246
+ } else if (env3.FORCE_COLOR === "false") {
21247
+ forceColor = 0;
21248
+ } else {
21249
+ forceColor = env3.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env3.FORCE_COLOR, 10), 3);
21250
+ }
21251
+ }
21252
+ function translateLevel3(level) {
21253
+ if (level === 0) {
21254
+ return false;
21255
+ }
21256
+ return {
21257
+ level,
21258
+ hasBasic: true,
21259
+ has256: level >= 2,
21260
+ has16m: level >= 3
21261
+ };
21262
+ }
21263
+ function supportsColor3(haveStream, streamIsTTY) {
21264
+ if (forceColor === 0) {
21265
+ return 0;
21266
+ }
21267
+ if (hasFlag3("color=16m") || hasFlag3("color=full") || hasFlag3("color=truecolor")) {
21268
+ return 3;
21269
+ }
21270
+ if (hasFlag3("color=256")) {
21271
+ return 2;
21272
+ }
21273
+ if (haveStream && !streamIsTTY && forceColor === void 0) {
21274
+ return 0;
21275
+ }
21276
+ const min = forceColor || 0;
21277
+ if (env3.TERM === "dumb") {
21278
+ return min;
21279
+ }
21280
+ if (process.platform === "win32") {
21281
+ const osRelease = os4.release().split(".");
21282
+ if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
21283
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
21284
+ }
21285
+ return 1;
21286
+ }
21287
+ if ("CI" in env3) {
21288
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env3) || env3.CI_NAME === "codeship") {
21289
+ return 1;
21290
+ }
21291
+ return min;
21292
+ }
21293
+ if ("TEAMCITY_VERSION" in env3) {
21294
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env3.TEAMCITY_VERSION) ? 1 : 0;
21295
+ }
21296
+ if (env3.COLORTERM === "truecolor") {
21297
+ return 3;
21298
+ }
21299
+ if ("TERM_PROGRAM" in env3) {
21300
+ const version = parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
21301
+ switch (env3.TERM_PROGRAM) {
21302
+ case "iTerm.app":
21303
+ return version >= 3 ? 3 : 2;
21304
+ case "Apple_Terminal":
21305
+ return 2;
21306
+ }
21307
+ }
21308
+ if (/-256(color)?$/i.test(env3.TERM)) {
21309
+ return 2;
21310
+ }
21311
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env3.TERM)) {
21312
+ return 1;
21313
+ }
21314
+ if ("COLORTERM" in env3) {
21315
+ return 1;
21316
+ }
21317
+ return min;
21318
+ }
21319
+ function getSupportLevel(stream4) {
21320
+ const level = supportsColor3(stream4, stream4 && stream4.isTTY);
21321
+ return translateLevel3(level);
21322
+ }
21323
+ module2.exports = {
21324
+ supportsColor: getSupportLevel,
21325
+ stdout: translateLevel3(supportsColor3(true, tty3.isatty(1))),
21326
+ stderr: translateLevel3(supportsColor3(true, tty3.isatty(2)))
21327
+ };
21328
+ }
21329
+ });
21330
+
21331
+ // ../../../node_modules/axios/node_modules/debug/src/node.js
21332
+ var require_node = __commonJS({
21333
+ "../../../node_modules/axios/node_modules/debug/src/node.js"(exports2, module2) {
21334
+ var tty3 = require("tty");
21335
+ var util4 = require("util");
21336
+ exports2.init = init;
21337
+ exports2.log = log;
21338
+ exports2.formatArgs = formatArgs;
21339
+ exports2.save = save;
21340
+ exports2.load = load2;
21341
+ exports2.useColors = useColors;
21342
+ exports2.destroy = util4.deprecate(
21343
+ () => {
21344
+ },
21345
+ "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
21346
+ );
21347
+ exports2.colors = [6, 2, 3, 4, 5, 1];
21348
+ try {
21349
+ const supportsColor3 = require_supports_color();
21350
+ if (supportsColor3 && (supportsColor3.stderr || supportsColor3).level >= 2) {
21351
+ exports2.colors = [
21352
+ 20,
21353
+ 21,
21354
+ 26,
21355
+ 27,
21356
+ 32,
21357
+ 33,
21358
+ 38,
21359
+ 39,
21360
+ 40,
21361
+ 41,
21362
+ 42,
21363
+ 43,
21364
+ 44,
21365
+ 45,
21366
+ 56,
21367
+ 57,
21368
+ 62,
21369
+ 63,
21370
+ 68,
21371
+ 69,
21372
+ 74,
21373
+ 75,
21374
+ 76,
21375
+ 77,
21376
+ 78,
21377
+ 79,
21378
+ 80,
21379
+ 81,
21380
+ 92,
21381
+ 93,
21382
+ 98,
21383
+ 99,
21384
+ 112,
21385
+ 113,
21386
+ 128,
21387
+ 129,
21388
+ 134,
21389
+ 135,
21390
+ 148,
21391
+ 149,
21392
+ 160,
21393
+ 161,
21394
+ 162,
21395
+ 163,
21396
+ 164,
21397
+ 165,
21398
+ 166,
21399
+ 167,
21400
+ 168,
21401
+ 169,
21402
+ 170,
21403
+ 171,
21404
+ 172,
21405
+ 173,
21406
+ 178,
21407
+ 179,
21408
+ 184,
21409
+ 185,
21410
+ 196,
21411
+ 197,
21412
+ 198,
21413
+ 199,
21414
+ 200,
21415
+ 201,
21416
+ 202,
21417
+ 203,
21418
+ 204,
21419
+ 205,
21420
+ 206,
21421
+ 207,
21422
+ 208,
21423
+ 209,
21424
+ 214,
21425
+ 215,
21426
+ 220,
21427
+ 221
21428
+ ];
21429
+ }
21430
+ } catch (error) {
21431
+ }
21432
+ exports2.inspectOpts = Object.keys(process.env).filter((key) => {
21433
+ return /^debug_/i.test(key);
21434
+ }).reduce((obj, key) => {
21435
+ const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
21436
+ return k.toUpperCase();
21437
+ });
21438
+ let val = process.env[key];
21439
+ if (/^(yes|on|true|enabled)$/i.test(val)) {
21440
+ val = true;
21441
+ } else if (/^(no|off|false|disabled)$/i.test(val)) {
21442
+ val = false;
21443
+ } else if (val === "null") {
21444
+ val = null;
21445
+ } else {
21446
+ val = Number(val);
21447
+ }
21448
+ obj[prop] = val;
21449
+ return obj;
21450
+ }, {});
21451
+ function useColors() {
21452
+ return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty3.isatty(process.stderr.fd);
21453
+ }
21454
+ function formatArgs(args2) {
21455
+ const { namespace: name, useColors: useColors2 } = this;
21456
+ if (useColors2) {
21457
+ const c = this.color;
21458
+ const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
21459
+ const prefix = ` ${colorCode};1m${name} \x1B[0m`;
21460
+ args2[0] = prefix + args2[0].split("\n").join("\n" + prefix);
21461
+ args2.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
21462
+ } else {
21463
+ args2[0] = getDate() + name + " " + args2[0];
21464
+ }
21465
+ }
21466
+ function getDate() {
21467
+ if (exports2.inspectOpts.hideDate) {
21468
+ return "";
21469
+ }
21470
+ return (/* @__PURE__ */ new Date()).toISOString() + " ";
21471
+ }
21472
+ function log(...args2) {
21473
+ return process.stderr.write(util4.formatWithOptions(exports2.inspectOpts, ...args2) + "\n");
21474
+ }
21475
+ function save(namespaces) {
21476
+ if (namespaces) {
21477
+ process.env.DEBUG = namespaces;
21478
+ } else {
21479
+ delete process.env.DEBUG;
21480
+ }
21481
+ }
21482
+ function load2() {
21483
+ return process.env.DEBUG;
21484
+ }
21485
+ function init(debug) {
21486
+ debug.inspectOpts = {};
21487
+ const keys = Object.keys(exports2.inspectOpts);
21488
+ for (let i = 0; i < keys.length; i++) {
21489
+ debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
21490
+ }
21491
+ }
21492
+ module2.exports = require_common2()(exports2);
21493
+ var { formatters } = module2.exports;
21494
+ formatters.o = function(v) {
21495
+ this.inspectOpts.colors = this.useColors;
21496
+ return util4.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
21497
+ };
21498
+ formatters.O = function(v) {
21499
+ this.inspectOpts.colors = this.useColors;
21500
+ return util4.inspect(v, this.inspectOpts);
21501
+ };
21502
+ }
21503
+ });
21504
+
21505
+ // ../../../node_modules/axios/node_modules/debug/src/index.js
21506
+ var require_src = __commonJS({
21507
+ "../../../node_modules/axios/node_modules/debug/src/index.js"(exports2, module2) {
21508
+ if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
21509
+ module2.exports = require_browser();
21510
+ } else {
21511
+ module2.exports = require_node();
21512
+ }
21513
+ }
21514
+ });
21515
+
21516
+ // ../../../node_modules/axios/node_modules/agent-base/dist/src/promisify.js
21517
+ var require_promisify = __commonJS({
21518
+ "../../../node_modules/axios/node_modules/agent-base/dist/src/promisify.js"(exports2) {
21519
+ "use strict";
21520
+ Object.defineProperty(exports2, "__esModule", { value: true });
21521
+ function promisify(fn) {
21522
+ return function(req, opts) {
21523
+ return new Promise((resolve3, reject) => {
21524
+ fn.call(this, req, opts, (err, rtn) => {
21525
+ if (err) {
21526
+ reject(err);
21527
+ } else {
21528
+ resolve3(rtn);
21529
+ }
21530
+ });
21531
+ });
21532
+ };
21533
+ }
21534
+ exports2.default = promisify;
21535
+ }
21536
+ });
21537
+
21538
+ // ../../../node_modules/axios/node_modules/agent-base/dist/src/index.js
21539
+ var require_src2 = __commonJS({
21540
+ "../../../node_modules/axios/node_modules/agent-base/dist/src/index.js"(exports2, module2) {
21541
+ "use strict";
21542
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
21543
+ return mod && mod.__esModule ? mod : { "default": mod };
21544
+ };
21545
+ var events_1 = require("events");
21546
+ var debug_1 = __importDefault(require_src());
21547
+ var promisify_1 = __importDefault(require_promisify());
21548
+ var debug = debug_1.default("agent-base");
21549
+ function isAgent(v) {
21550
+ return Boolean(v) && typeof v.addRequest === "function";
21551
+ }
21552
+ function isSecureEndpoint() {
21553
+ const { stack } = new Error();
21554
+ if (typeof stack !== "string")
21555
+ return false;
21556
+ return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
21557
+ }
21558
+ function createAgent(callback, opts) {
21559
+ return new createAgent.Agent(callback, opts);
21560
+ }
21561
+ (function(createAgent2) {
21562
+ class Agent2 extends events_1.EventEmitter {
21563
+ constructor(callback, _opts) {
21564
+ super();
21565
+ let opts = _opts;
21566
+ if (typeof callback === "function") {
21567
+ this.callback = callback;
21568
+ } else if (callback) {
21569
+ opts = callback;
21570
+ }
21571
+ this.timeout = null;
21572
+ if (opts && typeof opts.timeout === "number") {
21573
+ this.timeout = opts.timeout;
21574
+ }
21575
+ this.maxFreeSockets = 1;
21576
+ this.maxSockets = 1;
21577
+ this.maxTotalSockets = Infinity;
21578
+ this.sockets = {};
21579
+ this.freeSockets = {};
21580
+ this.requests = {};
21581
+ this.options = {};
21582
+ }
21583
+ get defaultPort() {
21584
+ if (typeof this.explicitDefaultPort === "number") {
21585
+ return this.explicitDefaultPort;
21586
+ }
21587
+ return isSecureEndpoint() ? 443 : 80;
21588
+ }
21589
+ set defaultPort(v) {
21590
+ this.explicitDefaultPort = v;
21591
+ }
21592
+ get protocol() {
21593
+ if (typeof this.explicitProtocol === "string") {
21594
+ return this.explicitProtocol;
21595
+ }
21596
+ return isSecureEndpoint() ? "https:" : "http:";
21597
+ }
21598
+ set protocol(v) {
21599
+ this.explicitProtocol = v;
21600
+ }
21601
+ callback(req, opts, fn) {
21602
+ throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
21603
+ }
21604
+ /**
21605
+ * Called by node-core's "_http_client.js" module when creating
21606
+ * a new HTTP request with this Agent instance.
21607
+ *
21608
+ * @api public
21609
+ */
21610
+ addRequest(req, _opts) {
21611
+ const opts = Object.assign({}, _opts);
21612
+ if (typeof opts.secureEndpoint !== "boolean") {
21613
+ opts.secureEndpoint = isSecureEndpoint();
21614
+ }
21615
+ if (opts.host == null) {
21616
+ opts.host = "localhost";
21617
+ }
21618
+ if (opts.port == null) {
21619
+ opts.port = opts.secureEndpoint ? 443 : 80;
21620
+ }
21621
+ if (opts.protocol == null) {
21622
+ opts.protocol = opts.secureEndpoint ? "https:" : "http:";
21623
+ }
21624
+ if (opts.host && opts.path) {
21625
+ delete opts.path;
21626
+ }
21627
+ delete opts.agent;
21628
+ delete opts.hostname;
21629
+ delete opts._defaultAgent;
21630
+ delete opts.defaultPort;
21631
+ delete opts.createConnection;
21632
+ req._last = true;
21633
+ req.shouldKeepAlive = false;
21634
+ let timedOut = false;
21635
+ let timeoutId = null;
21636
+ const timeoutMs = opts.timeout || this.timeout;
21637
+ const onerror = (err) => {
21638
+ if (req._hadError)
21639
+ return;
21640
+ req.emit("error", err);
21641
+ req._hadError = true;
21642
+ };
21643
+ const ontimeout = () => {
21644
+ timeoutId = null;
21645
+ timedOut = true;
21646
+ const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
21647
+ err.code = "ETIMEOUT";
21648
+ onerror(err);
21649
+ };
21650
+ const callbackError = (err) => {
21651
+ if (timedOut)
21652
+ return;
21653
+ if (timeoutId !== null) {
21654
+ clearTimeout(timeoutId);
21655
+ timeoutId = null;
21656
+ }
21657
+ onerror(err);
21658
+ };
21659
+ const onsocket = (socket) => {
21660
+ if (timedOut)
21661
+ return;
21662
+ if (timeoutId != null) {
21663
+ clearTimeout(timeoutId);
21664
+ timeoutId = null;
21665
+ }
21666
+ if (isAgent(socket)) {
21667
+ debug("Callback returned another Agent instance %o", socket.constructor.name);
21668
+ socket.addRequest(req, opts);
21669
+ return;
21670
+ }
21671
+ if (socket) {
21672
+ socket.once("free", () => {
21673
+ this.freeSocket(socket, opts);
21674
+ });
21675
+ req.onSocket(socket);
21676
+ return;
21677
+ }
21678
+ const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
21679
+ onerror(err);
21680
+ };
21681
+ if (typeof this.callback !== "function") {
21682
+ onerror(new Error("`callback` is not defined"));
21683
+ return;
21684
+ }
21685
+ if (!this.promisifiedCallback) {
21686
+ if (this.callback.length >= 3) {
21687
+ debug("Converting legacy callback function to promise");
21688
+ this.promisifiedCallback = promisify_1.default(this.callback);
21689
+ } else {
21690
+ this.promisifiedCallback = this.callback;
21691
+ }
21692
+ }
21693
+ if (typeof timeoutMs === "number" && timeoutMs > 0) {
21694
+ timeoutId = setTimeout(ontimeout, timeoutMs);
21695
+ }
21696
+ if ("port" in opts && typeof opts.port !== "number") {
21697
+ opts.port = Number(opts.port);
21698
+ }
21699
+ try {
21700
+ debug("Resolving socket for %o request: %o", opts.protocol, `${req.method} ${req.path}`);
21701
+ Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
21702
+ } catch (err) {
21703
+ Promise.reject(err).catch(callbackError);
21704
+ }
21705
+ }
21706
+ freeSocket(socket, opts) {
21707
+ debug("Freeing socket %o %o", socket.constructor.name, opts);
21708
+ socket.destroy();
21709
+ }
21710
+ destroy() {
21711
+ debug("Destroying agent %o", this.constructor.name);
21712
+ }
21713
+ }
21714
+ createAgent2.Agent = Agent2;
21715
+ createAgent2.prototype = createAgent2.Agent.prototype;
21716
+ })(createAgent || (createAgent = {}));
21717
+ module2.exports = createAgent;
21718
+ }
21719
+ });
21720
+
21721
+ // ../../../node_modules/axios/node_modules/https-proxy-agent/dist/parse-proxy-response.js
21722
+ var require_parse_proxy_response = __commonJS({
21723
+ "../../../node_modules/axios/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports2) {
21724
+ "use strict";
21725
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
21726
+ return mod && mod.__esModule ? mod : { "default": mod };
21727
+ };
21728
+ Object.defineProperty(exports2, "__esModule", { value: true });
21729
+ var debug_1 = __importDefault(require_src());
21730
+ var debug = debug_1.default("https-proxy-agent:parse-proxy-response");
21731
+ function parseProxyResponse(socket) {
21732
+ return new Promise((resolve3, reject) => {
21733
+ let buffersLength = 0;
21734
+ const buffers = [];
21735
+ function read() {
21736
+ const b = socket.read();
21737
+ if (b)
21738
+ ondata(b);
21739
+ else
21740
+ socket.once("readable", read);
21741
+ }
21742
+ function cleanup() {
21743
+ socket.removeListener("end", onend);
21744
+ socket.removeListener("error", onerror);
21745
+ socket.removeListener("close", onclose);
21746
+ socket.removeListener("readable", read);
21747
+ }
21748
+ function onclose(err) {
21749
+ debug("onclose had error %o", err);
21750
+ }
21751
+ function onend() {
21752
+ debug("onend");
21753
+ }
21754
+ function onerror(err) {
21755
+ cleanup();
21756
+ debug("onerror %o", err);
21757
+ reject(err);
21758
+ }
21759
+ function ondata(b) {
21760
+ buffers.push(b);
21761
+ buffersLength += b.length;
21762
+ const buffered = Buffer.concat(buffers, buffersLength);
21763
+ const endOfHeaders = buffered.indexOf("\r\n\r\n");
21764
+ if (endOfHeaders === -1) {
21765
+ debug("have not received end of HTTP headers yet...");
21766
+ read();
21767
+ return;
21768
+ }
21769
+ const firstLine = buffered.toString("ascii", 0, buffered.indexOf("\r\n"));
21770
+ const statusCode = +firstLine.split(" ")[1];
21771
+ debug("got proxy server response: %o", firstLine);
21772
+ resolve3({
21773
+ statusCode,
21774
+ buffered
21775
+ });
21776
+ }
21777
+ socket.on("error", onerror);
21778
+ socket.on("close", onclose);
21779
+ socket.on("end", onend);
21780
+ read();
21781
+ });
21782
+ }
21783
+ exports2.default = parseProxyResponse;
21784
+ }
21785
+ });
21786
+
21787
+ // ../../../node_modules/axios/node_modules/https-proxy-agent/dist/agent.js
21788
+ var require_agent = __commonJS({
21789
+ "../../../node_modules/axios/node_modules/https-proxy-agent/dist/agent.js"(exports2) {
21790
+ "use strict";
21791
+ var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
21792
+ function adopt(value) {
21793
+ return value instanceof P ? value : new P(function(resolve3) {
21794
+ resolve3(value);
21795
+ });
21796
+ }
21797
+ return new (P || (P = Promise))(function(resolve3, reject) {
21798
+ function fulfilled(value) {
21799
+ try {
21800
+ step(generator.next(value));
21801
+ } catch (e) {
21802
+ reject(e);
21803
+ }
21804
+ }
21805
+ function rejected(value) {
21806
+ try {
21807
+ step(generator["throw"](value));
21808
+ } catch (e) {
21809
+ reject(e);
21810
+ }
21811
+ }
21812
+ function step(result) {
21813
+ result.done ? resolve3(result.value) : adopt(result.value).then(fulfilled, rejected);
21814
+ }
21815
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
21816
+ });
21817
+ };
21818
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
21819
+ return mod && mod.__esModule ? mod : { "default": mod };
21820
+ };
21821
+ Object.defineProperty(exports2, "__esModule", { value: true });
21822
+ var net_1 = __importDefault(require("net"));
21823
+ var tls_1 = __importDefault(require("tls"));
21824
+ var url_1 = __importDefault(require("url"));
21825
+ var assert_1 = __importDefault(require("assert"));
21826
+ var debug_1 = __importDefault(require_src());
21827
+ var agent_base_1 = require_src2();
21828
+ var parse_proxy_response_1 = __importDefault(require_parse_proxy_response());
21829
+ var debug = debug_1.default("https-proxy-agent:agent");
21830
+ var HttpsProxyAgent2 = class extends agent_base_1.Agent {
21831
+ constructor(_opts) {
21832
+ let opts;
21833
+ if (typeof _opts === "string") {
21834
+ opts = url_1.default.parse(_opts);
21835
+ } else {
21836
+ opts = _opts;
21837
+ }
21838
+ if (!opts) {
21839
+ throw new Error("an HTTP(S) proxy server `host` and `port` must be specified!");
21840
+ }
21841
+ debug("creating new HttpsProxyAgent instance: %o", opts);
21842
+ super(opts);
21843
+ const proxy = Object.assign({}, opts);
21844
+ this.secureProxy = opts.secureProxy || isHTTPS(proxy.protocol);
21845
+ proxy.host = proxy.hostname || proxy.host;
21846
+ if (typeof proxy.port === "string") {
21847
+ proxy.port = parseInt(proxy.port, 10);
21848
+ }
21849
+ if (!proxy.port && proxy.host) {
21850
+ proxy.port = this.secureProxy ? 443 : 80;
21851
+ }
21852
+ if (this.secureProxy && !("ALPNProtocols" in proxy)) {
21853
+ proxy.ALPNProtocols = ["http 1.1"];
21854
+ }
21855
+ if (proxy.host && proxy.path) {
21856
+ delete proxy.path;
21857
+ delete proxy.pathname;
21858
+ }
21859
+ this.proxy = proxy;
21860
+ }
21861
+ /**
21862
+ * Called when the node-core HTTP client library is creating a
21863
+ * new HTTP request.
21864
+ *
21865
+ * @api protected
21866
+ */
21867
+ callback(req, opts) {
21868
+ return __awaiter(this, void 0, void 0, function* () {
21869
+ const { proxy, secureProxy } = this;
21870
+ let socket;
21871
+ if (secureProxy) {
21872
+ debug("Creating `tls.Socket`: %o", proxy);
21873
+ socket = tls_1.default.connect(proxy);
21874
+ } else {
21875
+ debug("Creating `net.Socket`: %o", proxy);
21876
+ socket = net_1.default.connect(proxy);
21877
+ }
21878
+ const headers = Object.assign({}, proxy.headers);
21879
+ const hostname = `${opts.host}:${opts.port}`;
21880
+ let payload = `CONNECT ${hostname} HTTP/1.1\r
21881
+ `;
21882
+ if (proxy.auth) {
21883
+ headers["Proxy-Authorization"] = `Basic ${Buffer.from(proxy.auth).toString("base64")}`;
21884
+ }
21885
+ let { host, port, secureEndpoint } = opts;
21886
+ if (!isDefaultPort(port, secureEndpoint)) {
21887
+ host += `:${port}`;
21888
+ }
21889
+ headers.Host = host;
21890
+ headers.Connection = "close";
21891
+ for (const name of Object.keys(headers)) {
21892
+ payload += `${name}: ${headers[name]}\r
21893
+ `;
21894
+ }
21895
+ const proxyResponsePromise = parse_proxy_response_1.default(socket);
21896
+ socket.write(`${payload}\r
21897
+ `);
21898
+ const { statusCode, buffered } = yield proxyResponsePromise;
21899
+ if (statusCode === 200) {
21900
+ req.once("socket", resume);
21901
+ if (opts.secureEndpoint) {
21902
+ debug("Upgrading socket connection to TLS");
21903
+ const servername = opts.servername || opts.host;
21904
+ return tls_1.default.connect(Object.assign(Object.assign({}, omit(opts, "host", "hostname", "path", "port")), {
21905
+ socket,
21906
+ servername
21907
+ }));
21908
+ }
21909
+ return socket;
21910
+ }
21911
+ socket.destroy();
21912
+ const fakeSocket = new net_1.default.Socket({ writable: false });
21913
+ fakeSocket.readable = true;
21914
+ req.once("socket", (s) => {
21915
+ debug("replaying proxy buffer for failed request");
21916
+ assert_1.default(s.listenerCount("data") > 0);
21917
+ s.push(buffered);
21918
+ s.push(null);
21919
+ });
21920
+ return fakeSocket;
21921
+ });
21922
+ }
21923
+ };
21924
+ exports2.default = HttpsProxyAgent2;
21925
+ function resume(socket) {
21926
+ socket.resume();
21927
+ }
21928
+ function isDefaultPort(port, secure) {
21929
+ return Boolean(!secure && port === 80 || secure && port === 443);
21930
+ }
21931
+ function isHTTPS(protocol) {
21932
+ return typeof protocol === "string" ? /^https:?$/i.test(protocol) : false;
21933
+ }
21934
+ function omit(obj, ...keys) {
21935
+ const ret = {};
21936
+ let key;
21937
+ for (key in obj) {
21938
+ if (!keys.includes(key)) {
21939
+ ret[key] = obj[key];
21940
+ }
21941
+ }
21942
+ return ret;
21943
+ }
21944
+ }
21945
+ });
21946
+
21947
+ // ../../../node_modules/axios/node_modules/https-proxy-agent/dist/index.js
21948
+ var require_dist = __commonJS({
21949
+ "../../../node_modules/axios/node_modules/https-proxy-agent/dist/index.js"(exports2, module2) {
21950
+ "use strict";
21951
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
21952
+ return mod && mod.__esModule ? mod : { "default": mod };
21953
+ };
21954
+ var agent_1 = __importDefault(require_agent());
21955
+ function createHttpsProxyAgent(opts) {
21956
+ return new agent_1.default(opts);
21957
+ }
21958
+ (function(createHttpsProxyAgent2) {
21959
+ createHttpsProxyAgent2.HttpsProxyAgent = agent_1.default;
21960
+ createHttpsProxyAgent2.prototype = agent_1.default.prototype;
21961
+ })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
21962
+ module2.exports = createHttpsProxyAgent;
21963
+ }
21964
+ });
21965
+
20753
21966
  // ../../../node_modules/debug/node_modules/ms/index.js
20754
- var require_ms = __commonJS({
21967
+ var require_ms2 = __commonJS({
20755
21968
  "../../../node_modules/debug/node_modules/ms/index.js"(exports2, module2) {
20756
21969
  var s = 1e3;
20757
21970
  var m = s * 60;
@@ -20860,7 +22073,7 @@ var require_debug = __commonJS({
20860
22073
  exports2.disable = disable;
20861
22074
  exports2.enable = enable;
20862
22075
  exports2.enabled = enabled;
20863
- exports2.humanize = require_ms();
22076
+ exports2.humanize = require_ms2();
20864
22077
  exports2.names = [];
20865
22078
  exports2.skips = [];
20866
22079
  exports2.formatters = {};
@@ -20958,7 +22171,7 @@ var require_debug = __commonJS({
20958
22171
  });
20959
22172
 
20960
22173
  // ../../../node_modules/debug/src/browser.js
20961
- var require_browser = __commonJS({
22174
+ var require_browser2 = __commonJS({
20962
22175
  "../../../node_modules/debug/src/browser.js"(exports2, module2) {
20963
22176
  exports2 = module2.exports = require_debug();
20964
22177
  exports2.log = log;
@@ -21044,10 +22257,10 @@ var require_browser = __commonJS({
21044
22257
  });
21045
22258
 
21046
22259
  // ../../../node_modules/debug/src/node.js
21047
- var require_node = __commonJS({
22260
+ var require_node2 = __commonJS({
21048
22261
  "../../../node_modules/debug/src/node.js"(exports2, module2) {
21049
22262
  var tty3 = require("tty");
21050
- var util3 = require("util");
22263
+ var util4 = require("util");
21051
22264
  exports2 = module2.exports = require_debug();
21052
22265
  exports2.init = init;
21053
22266
  exports2.log = log;
@@ -21072,7 +22285,7 @@ var require_node = __commonJS({
21072
22285
  }, {});
21073
22286
  var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
21074
22287
  if (1 !== fd && 2 !== fd) {
21075
- util3.deprecate(function() {
22288
+ util4.deprecate(function() {
21076
22289
  }, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
21077
22290
  }
21078
22291
  var stream4 = 1 === fd ? process.stdout : 2 === fd ? process.stderr : createWritableStdioStream(fd);
@@ -21081,13 +22294,13 @@ var require_node = __commonJS({
21081
22294
  }
21082
22295
  exports2.formatters.o = function(v) {
21083
22296
  this.inspectOpts.colors = this.useColors;
21084
- return util3.inspect(v, this.inspectOpts).split("\n").map(function(str) {
22297
+ return util4.inspect(v, this.inspectOpts).split("\n").map(function(str) {
21085
22298
  return str.trim();
21086
22299
  }).join(" ");
21087
22300
  };
21088
22301
  exports2.formatters.O = function(v) {
21089
22302
  this.inspectOpts.colors = this.useColors;
21090
- return util3.inspect(v, this.inspectOpts);
22303
+ return util4.inspect(v, this.inspectOpts);
21091
22304
  };
21092
22305
  function formatArgs(args2) {
21093
22306
  var name = this.namespace;
@@ -21102,7 +22315,7 @@ var require_node = __commonJS({
21102
22315
  }
21103
22316
  }
21104
22317
  function log() {
21105
- return stream4.write(util3.format.apply(util3, arguments) + "\n");
22318
+ return stream4.write(util4.format.apply(util4, arguments) + "\n");
21106
22319
  }
21107
22320
  function save(namespaces) {
21108
22321
  if (null == namespaces) {
@@ -21164,12 +22377,12 @@ var require_node = __commonJS({
21164
22377
  });
21165
22378
 
21166
22379
  // ../../../node_modules/debug/src/index.js
21167
- var require_src = __commonJS({
22380
+ var require_src3 = __commonJS({
21168
22381
  "../../../node_modules/debug/src/index.js"(exports2, module2) {
21169
22382
  if (typeof process !== "undefined" && process.type === "renderer") {
21170
- module2.exports = require_browser();
22383
+ module2.exports = require_browser2();
21171
22384
  } else {
21172
- module2.exports = require_node();
22385
+ module2.exports = require_node2();
21173
22386
  }
21174
22387
  }
21175
22388
  });
@@ -21181,7 +22394,7 @@ var require_debug2 = __commonJS({
21181
22394
  module2.exports = function() {
21182
22395
  if (!debug) {
21183
22396
  try {
21184
- debug = require_src()("follow-redirects");
22397
+ debug = require_src3()("follow-redirects");
21185
22398
  } catch (error) {
21186
22399
  }
21187
22400
  if (typeof debug !== "function") {
@@ -23667,6 +24880,23 @@ function bind(fn, thisArg) {
23667
24880
  var { toString } = Object.prototype;
23668
24881
  var { getPrototypeOf } = Object;
23669
24882
  var { iterator, toStringTag } = Symbol;
24883
+ var hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
24884
+ var hasOwnInPrototypeChain = (thing, prop) => {
24885
+ let obj = thing;
24886
+ const seen = [];
24887
+ while (obj != null && obj !== Object.prototype) {
24888
+ if (seen.indexOf(obj) !== -1) {
24889
+ return false;
24890
+ }
24891
+ seen.push(obj);
24892
+ if (hasOwnProperty(obj, prop)) {
24893
+ return true;
24894
+ }
24895
+ obj = getPrototypeOf(obj);
24896
+ }
24897
+ return false;
24898
+ };
24899
+ var getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : void 0;
23670
24900
  var kindOf = /* @__PURE__ */ ((cache) => (thing) => {
23671
24901
  const str = toString.call(thing);
23672
24902
  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
@@ -23697,11 +24927,14 @@ var isNumber = typeOfTest("number");
23697
24927
  var isObject = (thing) => thing !== null && typeof thing === "object";
23698
24928
  var isBoolean = (thing) => thing === true || thing === false;
23699
24929
  var isPlainObject = (val) => {
23700
- if (kindOf(val) !== "object") {
24930
+ if (!isObject(val)) {
23701
24931
  return false;
23702
24932
  }
23703
24933
  const prototype2 = getPrototypeOf(val);
23704
- return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
24934
+ return (prototype2 === null || prototype2 === Object.prototype || getPrototypeOf(prototype2) === null) && // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or
24935
+ // Symbol.iterator as evidence the value is a tagged/iterable type rather
24936
+ // than a plain object, while ignoring keys injected onto Object.prototype.
24937
+ !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);
23705
24938
  };
23706
24939
  var isEmptyObject = (val) => {
23707
24940
  if (!isObject(val) || isBuffer(val)) {
@@ -23805,7 +25038,7 @@ function merge(...objs) {
23805
25038
  if (key === "__proto__" || key === "constructor" || key === "prototype") {
23806
25039
  return;
23807
25040
  }
23808
- const targetKey = caseless && findKey(result, key) || key;
25041
+ const targetKey = caseless && typeof key === "string" && findKey(result, key) || key;
23809
25042
  const existing = hasOwnProperty(result, targetKey) ? result[targetKey] : void 0;
23810
25043
  if (isPlainObject(existing) && isPlainObject(val)) {
23811
25044
  result[targetKey] = merge(existing, val);
@@ -23818,7 +25051,21 @@ function merge(...objs) {
23818
25051
  }
23819
25052
  };
23820
25053
  for (let i = 0, l = objs.length; i < l; i++) {
23821
- objs[i] && forEach(objs[i], assignValue);
25054
+ const source = objs[i];
25055
+ if (!source || isBuffer(source)) {
25056
+ continue;
25057
+ }
25058
+ forEach(source, assignValue);
25059
+ if (typeof source !== "object" || isArray(source)) {
25060
+ continue;
25061
+ }
25062
+ const symbols = Object.getOwnPropertySymbols(source);
25063
+ for (let j = 0; j < symbols.length; j++) {
25064
+ const symbol = symbols[j];
25065
+ if (propertyIsEnumerable.call(source, symbol)) {
25066
+ assignValue(source[symbol], symbol);
25067
+ }
25068
+ }
23822
25069
  }
23823
25070
  return result;
23824
25071
  }
@@ -23940,7 +25187,7 @@ var toCamelCase = (str) => {
23940
25187
  return p1.toUpperCase() + p2;
23941
25188
  });
23942
25189
  };
23943
- var hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
25190
+ var { propertyIsEnumerable } = Object.prototype;
23944
25191
  var isRegExp = kindOfTest("RegExp");
23945
25192
  var reduceDescriptors = (obj, reducer) => {
23946
25193
  const descriptors = Object.getOwnPropertyDescriptors(obj);
@@ -23991,29 +25238,29 @@ function isSpecCompliantForm(thing) {
23991
25238
  return !!(thing && isFunction(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
23992
25239
  }
23993
25240
  var toJSONObject = (obj) => {
23994
- const stack = new Array(10);
23995
- const visit = (source, i) => {
25241
+ const visited = /* @__PURE__ */ new WeakSet();
25242
+ const visit = (source) => {
23996
25243
  if (isObject(source)) {
23997
- if (stack.indexOf(source) >= 0) {
25244
+ if (visited.has(source)) {
23998
25245
  return;
23999
25246
  }
24000
25247
  if (isBuffer(source)) {
24001
25248
  return source;
24002
25249
  }
24003
25250
  if (!("toJSON" in source)) {
24004
- stack[i] = source;
25251
+ visited.add(source);
24005
25252
  const target = isArray(source) ? [] : {};
24006
25253
  forEach(source, (value, key) => {
24007
- const reducedValue = visit(value, i + 1);
25254
+ const reducedValue = visit(value);
24008
25255
  !isUndefined(reducedValue) && (target[key] = reducedValue);
24009
25256
  });
24010
- stack[i] = void 0;
25257
+ visited.delete(source);
24011
25258
  return target;
24012
25259
  }
24013
25260
  }
24014
25261
  return source;
24015
25262
  };
24016
- return visit(obj, 0);
25263
+ return visit(obj);
24017
25264
  };
24018
25265
  var isAsyncFn = kindOfTest("AsyncFunction");
24019
25266
  var isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
@@ -24039,6 +25286,7 @@ var _setImmediate = ((setImmediateSupported, postMessageSupported) => {
24039
25286
  })(typeof setImmediate === "function", isFunction(_global.postMessage));
24040
25287
  var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
24041
25288
  var isIterable = (thing) => thing != null && isFunction(thing[iterator]);
25289
+ var isSafeIterable = (thing) => thing != null && hasOwnInPrototypeChain(thing, iterator) && isIterable(thing);
24042
25290
  var utils_default = {
24043
25291
  isArray,
24044
25292
  isArrayBuffer,
@@ -24084,6 +25332,8 @@ var utils_default = {
24084
25332
  hasOwnProperty,
24085
25333
  hasOwnProp: hasOwnProperty,
24086
25334
  // an alias to avoid ESLint no-prototype-builtins detection
25335
+ hasOwnInPrototypeChain,
25336
+ getSafeProp,
24087
25337
  reduceDescriptors,
24088
25338
  freezeMethods,
24089
25339
  toObjectSet,
@@ -24099,7 +25349,8 @@ var utils_default = {
24099
25349
  isThenable,
24100
25350
  setImmediate: _setImmediate,
24101
25351
  asap,
24102
- isIterable
25352
+ isIterable,
25353
+ isSafeIterable
24103
25354
  };
24104
25355
 
24105
25356
  // ../../../node_modules/axios/lib/helpers/parseHeaders.js
@@ -24147,9 +25398,7 @@ var parseHeaders_default = (rawHeaders) => {
24147
25398
  return parsed;
24148
25399
  };
24149
25400
 
24150
- // ../../../node_modules/axios/lib/core/AxiosHeaders.js
24151
- var $internals = /* @__PURE__ */ Symbol("internals");
24152
- var INVALID_HEADER_VALUE_CHARS_RE = /[^\x09\x20-\x7E\x80-\xFF]/g;
25401
+ // ../../../node_modules/axios/lib/helpers/sanitizeHeaderValue.js
24153
25402
  function trimSPorHTAB(str) {
24154
25403
  let start = 0;
24155
25404
  let end = str.length;
@@ -24169,12 +25418,29 @@ function trimSPorHTAB(str) {
24169
25418
  }
24170
25419
  return start === 0 && end === str.length ? str : str.slice(start, end);
24171
25420
  }
25421
+ var INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp("[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+", "g");
25422
+ var INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp("[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+", "g");
25423
+ function sanitizeValue(value, invalidChars) {
25424
+ if (utils_default.isArray(value)) {
25425
+ return value.map((item) => sanitizeValue(item, invalidChars));
25426
+ }
25427
+ return trimSPorHTAB(String(value).replace(invalidChars, ""));
25428
+ }
25429
+ var sanitizeHeaderValue = (value) => sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);
25430
+ var sanitizeByteStringHeaderValue = (value) => sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
25431
+ function toByteStringHeaderObject(headers) {
25432
+ const byteStringHeaders = /* @__PURE__ */ Object.create(null);
25433
+ utils_default.forEach(headers.toJSON(), (value, header) => {
25434
+ byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
25435
+ });
25436
+ return byteStringHeaders;
25437
+ }
25438
+
25439
+ // ../../../node_modules/axios/lib/core/AxiosHeaders.js
25440
+ var $internals = /* @__PURE__ */ Symbol("internals");
24172
25441
  function normalizeHeader(header) {
24173
25442
  return header && String(header).trim().toLowerCase();
24174
25443
  }
24175
- function sanitizeHeaderValue(str) {
24176
- return trimSPorHTAB(str.replace(INVALID_HEADER_VALUE_CHARS_RE, ""));
24177
- }
24178
25444
  function normalizeValue(value) {
24179
25445
  if (value === false || value == null) {
24180
25446
  return value;
@@ -24234,7 +25500,7 @@ var AxiosHeaders = class {
24234
25500
  function setHeader(_value, _header, _rewrite) {
24235
25501
  const lHeader = normalizeHeader(_header);
24236
25502
  if (!lHeader) {
24237
- throw new Error("header name must be a non-empty string");
25503
+ return;
24238
25504
  }
24239
25505
  const key = utils_default.findKey(self2, lHeader);
24240
25506
  if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) {
@@ -24246,13 +25512,19 @@ var AxiosHeaders = class {
24246
25512
  setHeaders(header, valueOrRewrite);
24247
25513
  } else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
24248
25514
  setHeaders(parseHeaders_default(header), valueOrRewrite);
24249
- } else if (utils_default.isObject(header) && utils_default.isIterable(header)) {
24250
- let obj = {}, dest, key;
25515
+ } else if (utils_default.isObject(header) && utils_default.isSafeIterable(header)) {
25516
+ let obj = /* @__PURE__ */ Object.create(null), dest, key;
24251
25517
  for (const entry of header) {
24252
25518
  if (!utils_default.isArray(entry)) {
24253
- throw TypeError("Object iterator must return a key-value pair");
25519
+ throw new TypeError("Object iterator must return a key-value pair");
25520
+ }
25521
+ key = entry[0];
25522
+ if (utils_default.hasOwnProp(obj, key)) {
25523
+ dest = obj[key];
25524
+ obj[key] = utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];
25525
+ } else {
25526
+ obj[key] = entry[1];
24254
25527
  }
24255
- obj[key = entry[0]] = (dest = obj[key]) ? utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
24256
25528
  }
24257
25529
  setHeaders(obj, valueOrRewrite);
24258
25530
  } else {
@@ -24549,6 +25821,7 @@ var import_form_data = __toESM(require_form_data(), 1);
24549
25821
  var FormData_default = import_form_data.default;
24550
25822
 
24551
25823
  // ../../../node_modules/axios/lib/helpers/toFormData.js
25824
+ var DEFAULT_FORM_DATA_MAX_DEPTH = 100;
24552
25825
  function isVisitable(thing) {
24553
25826
  return utils_default.isPlainObject(thing) || utils_default.isArray(thing);
24554
25827
  }
@@ -24590,8 +25863,9 @@ function toFormData(obj, formData, options) {
24590
25863
  const dots = options.dots;
24591
25864
  const indexes = options.indexes;
24592
25865
  const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
24593
- const maxDepth = options.maxDepth === void 0 ? 100 : options.maxDepth;
25866
+ const maxDepth = options.maxDepth === void 0 ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
24594
25867
  const useBlob = _Blob && utils_default.isSpecCompliantForm(formData);
25868
+ const stack = [];
24595
25869
  if (!utils_default.isFunction(visitor)) {
24596
25870
  throw new TypeError("visitor must be a function");
24597
25871
  }
@@ -24611,6 +25885,31 @@ function toFormData(obj, formData, options) {
24611
25885
  }
24612
25886
  return value;
24613
25887
  }
25888
+ function throwIfMaxDepthExceeded(depth) {
25889
+ if (depth > maxDepth) {
25890
+ throw new AxiosError_default(
25891
+ "Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth,
25892
+ AxiosError_default.ERR_FORM_DATA_DEPTH_EXCEEDED
25893
+ );
25894
+ }
25895
+ }
25896
+ function stringifyWithDepthLimit(value, depth) {
25897
+ if (maxDepth === Infinity) {
25898
+ return JSON.stringify(value);
25899
+ }
25900
+ const ancestors = [];
25901
+ return JSON.stringify(value, function limitDepth(_key, currentValue) {
25902
+ if (!utils_default.isObject(currentValue)) {
25903
+ return currentValue;
25904
+ }
25905
+ while (ancestors.length && ancestors[ancestors.length - 1] !== this) {
25906
+ ancestors.pop();
25907
+ }
25908
+ ancestors.push(currentValue);
25909
+ throwIfMaxDepthExceeded(depth + ancestors.length - 1);
25910
+ return currentValue;
25911
+ });
25912
+ }
24614
25913
  function defaultVisitor(value, key, path) {
24615
25914
  let arr = value;
24616
25915
  if (utils_default.isReactNative(formData) && utils_default.isReactNativeBlob(value)) {
@@ -24620,7 +25919,7 @@ function toFormData(obj, formData, options) {
24620
25919
  if (value && !path && typeof value === "object") {
24621
25920
  if (utils_default.endsWith(key, "{}")) {
24622
25921
  key = metaTokens ? key : key.slice(0, -2);
24623
- value = JSON.stringify(value);
25922
+ value = stringifyWithDepthLimit(value, 1);
24624
25923
  } else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) {
24625
25924
  key = removeBrackets(key);
24626
25925
  arr.forEach(function each(el, index) {
@@ -24639,7 +25938,6 @@ function toFormData(obj, formData, options) {
24639
25938
  formData.append(renderKey(path, key, dots), convertValue(value));
24640
25939
  return false;
24641
25940
  }
24642
- const stack = [];
24643
25941
  const exposedHelpers = Object.assign(predicates, {
24644
25942
  defaultVisitor,
24645
25943
  convertValue,
@@ -24647,14 +25945,9 @@ function toFormData(obj, formData, options) {
24647
25945
  });
24648
25946
  function build(value, path, depth = 0) {
24649
25947
  if (utils_default.isUndefined(value)) return;
24650
- if (depth > maxDepth) {
24651
- throw new AxiosError_default(
24652
- "Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth,
24653
- AxiosError_default.ERR_FORM_DATA_DEPTH_EXCEEDED
24654
- );
24655
- }
25948
+ throwIfMaxDepthExceeded(depth);
24656
25949
  if (stack.indexOf(value) !== -1) {
24657
- throw Error("Circular reference detected in " + path.join("."));
25950
+ throw new Error("Circular reference detected in " + path.join("."));
24658
25951
  }
24659
25952
  stack.push(value);
24660
25953
  utils_default.forEach(value, function each(el, key) {
@@ -24713,11 +26006,11 @@ function buildURL(url2, params, options) {
24713
26006
  if (!params) {
24714
26007
  return url2;
24715
26008
  }
24716
- const _encode = options && options.encode || encode2;
24717
26009
  const _options = utils_default.isFunction(options) ? {
24718
26010
  serialize: options
24719
26011
  } : options;
24720
- const serializeFn = _options && _options.serialize;
26012
+ const _encode = utils_default.getSafeProp(_options, "encode") || encode2;
26013
+ const serializeFn = utils_default.getSafeProp(_options, "serialize");
24721
26014
  let serializedParams;
24722
26015
  if (serializeFn) {
24723
26016
  serializedParams = serializeFn(params, _options);
@@ -24804,7 +26097,9 @@ var transitional_default = {
24804
26097
  silentJSONParsing: true,
24805
26098
  forcedJSONParsing: true,
24806
26099
  clarifyTimeoutError: false,
24807
- legacyInterceptorReqResOrdering: true
26100
+ legacyInterceptorReqResOrdering: true,
26101
+ advertiseZstdAcceptEncoding: false,
26102
+ validateStatusUndefinedResolves: true
24808
26103
  };
24809
26104
 
24810
26105
  // ../../../node_modules/axios/lib/platform/node/index.js
@@ -24883,10 +26178,24 @@ function toURLEncodedForm(data, options) {
24883
26178
  }
24884
26179
 
24885
26180
  // ../../../node_modules/axios/lib/helpers/formDataToJSON.js
26181
+ var MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
26182
+ function throwIfDepthExceeded(index) {
26183
+ if (index > MAX_DEPTH) {
26184
+ throw new AxiosError_default(
26185
+ "FormData field is too deeply nested (" + index + " levels). Max depth: " + MAX_DEPTH,
26186
+ AxiosError_default.ERR_FORM_DATA_DEPTH_EXCEEDED
26187
+ );
26188
+ }
26189
+ }
24886
26190
  function parsePropPath(name) {
24887
- return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
24888
- return match[0] === "[]" ? "" : match[1] || match[0];
24889
- });
26191
+ const path = [];
26192
+ const pattern = /\w+|\[(\w*)]/g;
26193
+ let match;
26194
+ while ((match = pattern.exec(name)) !== null) {
26195
+ throwIfDepthExceeded(path.length);
26196
+ path.push(match[0] === "[]" ? "" : match[1] || match[0]);
26197
+ }
26198
+ return path;
24890
26199
  }
24891
26200
  function arrayToObject(arr) {
24892
26201
  const obj = {};
@@ -24902,6 +26211,7 @@ function arrayToObject(arr) {
24902
26211
  }
24903
26212
  function formDataToJSON(formData) {
24904
26213
  function buildPath(path, value, target, index) {
26214
+ throwIfDepthExceeded(index);
24905
26215
  let name = path[index++];
24906
26216
  if (name === "__proto__") return true;
24907
26217
  const isNumericKey = Number.isFinite(+name);
@@ -24915,7 +26225,7 @@ function formDataToJSON(formData) {
24915
26225
  }
24916
26226
  return !isNumericKey;
24917
26227
  }
24918
- if (!target[name] || !utils_default.isObject(target[name])) {
26228
+ if (!utils_default.hasOwnProp(target, name) || !utils_default.isObject(target[name])) {
24919
26229
  target[name] = [];
24920
26230
  }
24921
26231
  const result = buildPath(path, value, target[name], index);
@@ -25119,9 +26429,32 @@ function combineURLs(baseURL, relativeURL) {
25119
26429
  }
25120
26430
 
25121
26431
  // ../../../node_modules/axios/lib/core/buildFullPath.js
25122
- function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
26432
+ var malformedHttpProtocol = /^https?:(?!\/\/)/i;
26433
+ var httpProtocolControlCharacters = /[\t\n\r]/g;
26434
+ function stripLeadingC0ControlOrSpace(url2) {
26435
+ let i = 0;
26436
+ while (i < url2.length && url2.charCodeAt(i) <= 32) {
26437
+ i++;
26438
+ }
26439
+ return url2.slice(i);
26440
+ }
26441
+ function normalizeURLForProtocolCheck(url2) {
26442
+ return stripLeadingC0ControlOrSpace(url2).replace(httpProtocolControlCharacters, "");
26443
+ }
26444
+ function assertValidHttpProtocolURL(url2, config) {
26445
+ if (typeof url2 === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url2))) {
26446
+ throw new AxiosError_default(
26447
+ 'Invalid URL: missing "//" after protocol',
26448
+ AxiosError_default.ERR_INVALID_URL,
26449
+ config
26450
+ );
26451
+ }
26452
+ }
26453
+ function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {
26454
+ assertValidHttpProtocolURL(requestedURL, config);
25123
26455
  let isRelativeUrl = !isAbsoluteURL(requestedURL);
25124
26456
  if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
26457
+ assertValidHttpProtocolURL(baseURL, config);
25125
26458
  return combineURLs(baseURL, requestedURL);
25126
26459
  }
25127
26460
  return requestedURL;
@@ -25195,16 +26528,17 @@ function getEnv(key) {
25195
26528
  }
25196
26529
 
25197
26530
  // ../../../node_modules/axios/lib/adapters/http.js
26531
+ var import_https_proxy_agent = __toESM(require_dist(), 1);
25198
26532
  var import_http = __toESM(require("http"), 1);
25199
26533
  var import_https = __toESM(require("https"), 1);
25200
- var import_http2 = __toESM(require("http2"), 1);
25201
- var import_util3 = __toESM(require("util"), 1);
26534
+ var import_http22 = __toESM(require("http2"), 1);
26535
+ var import_util4 = __toESM(require("util"), 1);
25202
26536
  var import_path = require("path");
25203
26537
  var import_follow_redirects = __toESM(require_follow_redirects(), 1);
25204
26538
  var import_zlib = __toESM(require("zlib"), 1);
25205
26539
 
25206
26540
  // ../../../node_modules/axios/lib/env/data.js
25207
- var VERSION = "1.16.0";
26541
+ var VERSION = "1.18.0";
25208
26542
 
25209
26543
  // ../../../node_modules/axios/lib/helpers/parseProtocol.js
25210
26544
  function parseProtocol(url2) {
@@ -25213,7 +26547,7 @@ function parseProtocol(url2) {
25213
26547
  }
25214
26548
 
25215
26549
  // ../../../node_modules/axios/lib/helpers/fromDataURI.js
25216
- var DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
26550
+ var DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/;
25217
26551
  function fromDataURI(uri, asBlob, options) {
25218
26552
  const _Blob = options && options.Blob || platform_default.classes.Blob;
25219
26553
  const protocol = parseProtocol(uri);
@@ -25226,10 +26560,17 @@ function fromDataURI(uri, asBlob, options) {
25226
26560
  if (!match) {
25227
26561
  throw new AxiosError_default("Invalid URL", AxiosError_default.ERR_INVALID_URL);
25228
26562
  }
25229
- const mime = match[1];
25230
- const isBase64 = match[2];
25231
- const body = match[3];
25232
- const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
26563
+ const type = match[1];
26564
+ const params = match[2];
26565
+ const encoding = match[3] ? "base64" : "utf8";
26566
+ const body = match[4];
26567
+ let mime;
26568
+ if (type) {
26569
+ mime = params ? type + params : type;
26570
+ } else if (params) {
26571
+ mime = "text/plain" + params;
26572
+ }
26573
+ const buffer = Buffer.from(decodeURIComponent(body), encoding);
25233
26574
  if (asBlob) {
25234
26575
  if (!_Blob) {
25235
26576
  throw new AxiosError_default("Blob is not supported", AxiosError_default.ERR_NOT_SUPPORT);
@@ -25440,10 +26781,10 @@ var formDataToStream = (form, headersHandler, options) => {
25440
26781
  boundary = tag + "-" + platform_default.generateString(size, BOUNDARY_ALPHABET)
25441
26782
  } = options || {};
25442
26783
  if (!utils_default.isFormData(form)) {
25443
- throw TypeError("FormData instance required");
26784
+ throw new TypeError("FormData instance required");
25444
26785
  }
25445
26786
  if (boundary.length < 1 || boundary.length > 70) {
25446
- throw Error("boundary must be 1-70 characters long");
26787
+ throw new Error("boundary must be 1-70 characters long");
25447
26788
  }
25448
26789
  const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
25449
26790
  const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF);
@@ -25491,10 +26832,91 @@ var ZlibHeaderTransformStream = class extends import_stream4.default.Transform {
25491
26832
  this.push(header, encoding);
25492
26833
  }
25493
26834
  }
25494
- this.__transform(chunk, encoding, callback);
26835
+ this.__transform(chunk, encoding, callback);
26836
+ }
26837
+ };
26838
+ var ZlibHeaderTransformStream_default = ZlibHeaderTransformStream;
26839
+
26840
+ // ../../../node_modules/axios/lib/helpers/Http2Sessions.js
26841
+ var import_http2 = __toESM(require("http2"), 1);
26842
+ var import_util3 = __toESM(require("util"), 1);
26843
+ var Http2Sessions = class {
26844
+ constructor() {
26845
+ this.sessions = /* @__PURE__ */ Object.create(null);
26846
+ }
26847
+ getSession(authority, options) {
26848
+ options = Object.assign(
26849
+ {
26850
+ sessionTimeout: 1e3
26851
+ },
26852
+ options
26853
+ );
26854
+ let authoritySessions = this.sessions[authority];
26855
+ if (authoritySessions) {
26856
+ let len = authoritySessions.length;
26857
+ for (let i = 0; i < len; i++) {
26858
+ const [sessionHandle, sessionOptions] = authoritySessions[i];
26859
+ if (!sessionHandle.destroyed && !sessionHandle.closed && import_util3.default.isDeepStrictEqual(sessionOptions, options)) {
26860
+ return sessionHandle;
26861
+ }
26862
+ }
26863
+ }
26864
+ const session = import_http2.default.connect(authority, options);
26865
+ let removed;
26866
+ let timer;
26867
+ const removeSession = () => {
26868
+ if (removed) {
26869
+ return;
26870
+ }
26871
+ removed = true;
26872
+ if (timer) {
26873
+ clearTimeout(timer);
26874
+ timer = null;
26875
+ }
26876
+ let entries = authoritySessions, len = entries.length, i = len;
26877
+ while (i--) {
26878
+ if (entries[i][0] === session) {
26879
+ if (len === 1) {
26880
+ delete this.sessions[authority];
26881
+ } else {
26882
+ entries.splice(i, 1);
26883
+ }
26884
+ if (!session.closed) {
26885
+ session.close();
26886
+ }
26887
+ return;
26888
+ }
26889
+ }
26890
+ };
26891
+ const originalRequestFn = session.request;
26892
+ const { sessionTimeout } = options;
26893
+ if (sessionTimeout != null) {
26894
+ let streamsCount = 0;
26895
+ session.request = function() {
26896
+ const stream4 = originalRequestFn.apply(this, arguments);
26897
+ streamsCount++;
26898
+ if (timer) {
26899
+ clearTimeout(timer);
26900
+ timer = null;
26901
+ }
26902
+ stream4.once("close", () => {
26903
+ if (!--streamsCount) {
26904
+ timer = setTimeout(() => {
26905
+ timer = null;
26906
+ removeSession();
26907
+ }, sessionTimeout);
26908
+ }
26909
+ });
26910
+ return stream4;
26911
+ };
26912
+ }
26913
+ session.once("close", removeSession);
26914
+ let entry = [session, options];
26915
+ authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
26916
+ return session;
25495
26917
  }
25496
26918
  };
25497
- var ZlibHeaderTransformStream_default = ZlibHeaderTransformStream;
26919
+ var Http2Sessions_default = Http2Sessions;
25498
26920
 
25499
26921
  // ../../../node_modules/axios/lib/helpers/callbackify.js
25500
26922
  var callbackify = (fn, reducer) => {
@@ -25512,13 +26934,29 @@ var callbackify = (fn, reducer) => {
25512
26934
  var callbackify_default = callbackify;
25513
26935
 
25514
26936
  // ../../../node_modules/axios/lib/helpers/shouldBypassProxy.js
25515
- var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost"]);
26937
+ var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "0.0.0.0"]);
25516
26938
  var isIPv4Loopback = (host) => {
25517
26939
  const parts = host.split(".");
25518
26940
  if (parts.length !== 4) return false;
25519
26941
  if (parts[0] !== "127") return false;
25520
26942
  return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
25521
26943
  };
26944
+ var isIPv6ZeroGroup = (group) => /^0{1,4}$/.test(group);
26945
+ var isIPv6Unspecified = (host) => {
26946
+ if (host === "::") return true;
26947
+ const compressionIndex = host.indexOf("::");
26948
+ if (compressionIndex !== -1) {
26949
+ if (compressionIndex !== host.lastIndexOf("::")) return false;
26950
+ const left = host.slice(0, compressionIndex);
26951
+ const right = host.slice(compressionIndex + 2);
26952
+ const leftGroups = left ? left.split(":") : [];
26953
+ const rightGroups = right ? right.split(":") : [];
26954
+ const explicitGroups = leftGroups.length + rightGroups.length;
26955
+ return explicitGroups < 8 && leftGroups.every(isIPv6ZeroGroup) && rightGroups.every(isIPv6ZeroGroup);
26956
+ }
26957
+ const groups = host.split(":");
26958
+ return groups.length === 8 && groups.every(isIPv6ZeroGroup);
26959
+ };
25522
26960
  var isIPv6Loopback = (host) => {
25523
26961
  if (host === "::1") return true;
25524
26962
  const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
@@ -25541,6 +26979,7 @@ var isLoopback = (host) => {
25541
26979
  if (!host) return false;
25542
26980
  if (LOOPBACK_HOSTNAMES.has(host)) return true;
25543
26981
  if (isIPv4Loopback(host)) return true;
26982
+ if (isIPv6Unspecified(host)) return true;
25544
26983
  return isIPv6Loopback(host);
25545
26984
  };
25546
26985
  var DEFAULT_PORTS2 = {
@@ -25709,6 +27148,9 @@ var progressEventReducer = (listener, isDownloadStream, freq = 3) => {
25709
27148
  let bytesNotified = 0;
25710
27149
  const _speedometer = speedometer_default(50, 250);
25711
27150
  return throttle_default((e) => {
27151
+ if (!e || typeof e.loaded !== "number") {
27152
+ return;
27153
+ }
25712
27154
  const rawLoaded = e.loaded;
25713
27155
  const total = e.lengthComputable ? e.total : void 0;
25714
27156
  const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
@@ -25743,6 +27185,8 @@ var progressEventDecorator = (total, throttled) => {
25743
27185
  var asyncDecorator = (fn) => (...args2) => utils_default.asap(() => fn(...args2));
25744
27186
 
25745
27187
  // ../../../node_modules/axios/lib/helpers/estimateDataURLDecodedBytes.js
27188
+ var isHexDigit = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;
27189
+ var isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
25746
27190
  function estimateDataURLDecodedBytes(url2) {
25747
27191
  if (!url2 || typeof url2 !== "string") return 0;
25748
27192
  if (!url2.startsWith("data:")) return 0;
@@ -25758,7 +27202,7 @@ function estimateDataURLDecodedBytes(url2) {
25758
27202
  if (body.charCodeAt(i) === 37 && i + 2 < len) {
25759
27203
  const a = body.charCodeAt(i + 1);
25760
27204
  const b = body.charCodeAt(i + 2);
25761
- const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
27205
+ const isHex = isHexDigit(a) && isHexDigit(b);
25762
27206
  if (isHex) {
25763
27207
  effectiveLen -= 2;
25764
27208
  i += 2;
@@ -25790,13 +27234,13 @@ function estimateDataURLDecodedBytes(url2) {
25790
27234
  const bytes2 = groups * 3 - (pad || 0);
25791
27235
  return bytes2 > 0 ? bytes2 : 0;
25792
27236
  }
25793
- if (typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function") {
25794
- return Buffer.byteLength(body, "utf8");
25795
- }
25796
27237
  let bytes = 0;
25797
27238
  for (let i = 0, len = body.length; i < len; i++) {
25798
27239
  const c = body.charCodeAt(i);
25799
- if (c < 128) {
27240
+ if (c === 37 && isPercentEncodedByte(body, i, len)) {
27241
+ bytes += 1;
27242
+ i += 2;
27243
+ } else if (c < 128) {
25800
27244
  bytes += 1;
25801
27245
  } else if (c < 2048) {
25802
27246
  bytes += 2;
@@ -25824,7 +27268,14 @@ var brotliOptions = {
25824
27268
  flush: import_zlib.default.constants.BROTLI_OPERATION_FLUSH,
25825
27269
  finishFlush: import_zlib.default.constants.BROTLI_OPERATION_FLUSH
25826
27270
  };
27271
+ var zstdOptions = {
27272
+ flush: import_zlib.default.constants.ZSTD_e_flush,
27273
+ finishFlush: import_zlib.default.constants.ZSTD_e_flush
27274
+ };
25827
27275
  var isBrotliSupported = utils_default.isFunction(import_zlib.default.createBrotliDecompress);
27276
+ var isZstdSupported = utils_default.isFunction(import_zlib.default.createZstdDecompress);
27277
+ var ACCEPT_ENCODING = "gzip, compress, deflate" + (isBrotliSupported ? ", br" : "");
27278
+ var ACCEPT_ENCODING_WITH_ZSTD = ACCEPT_ENCODING + (isZstdSupported ? ", zstd" : "");
25828
27279
  var { http: httpFollow, https: httpsFollow } = import_follow_redirects.default;
25829
27280
  var isHttps = /https:?/;
25830
27281
  var FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
@@ -25841,6 +27292,27 @@ function setFormDataHeaders(headers, formHeaders, policy) {
25841
27292
  }
25842
27293
  var kAxiosSocketListener = /* @__PURE__ */ Symbol("axios.http.socketListener");
25843
27294
  var kAxiosCurrentReq = /* @__PURE__ */ Symbol("axios.http.currentReq");
27295
+ var kAxiosInstalledTunnel = /* @__PURE__ */ Symbol("axios.http.installedTunnel");
27296
+ var tunnelingAgentCache = /* @__PURE__ */ new Map();
27297
+ var tunnelingAgentCacheUser = /* @__PURE__ */ new WeakMap();
27298
+ function getTunnelingAgent(agentOptions, userHttpsAgent) {
27299
+ const key = agentOptions.protocol + "//" + agentOptions.hostname + ":" + (agentOptions.port || "") + "#" + (agentOptions.auth || "");
27300
+ const cache = userHttpsAgent ? tunnelingAgentCacheUser.get(userHttpsAgent) || tunnelingAgentCacheUser.set(userHttpsAgent, /* @__PURE__ */ new Map()).get(userHttpsAgent) : tunnelingAgentCache;
27301
+ let agent = cache.get(key);
27302
+ if (agent) return agent;
27303
+ const merged = userHttpsAgent && userHttpsAgent.options ? { ...userHttpsAgent.options, ...agentOptions } : agentOptions;
27304
+ agent = new import_https_proxy_agent.default(merged);
27305
+ if (userHttpsAgent && userHttpsAgent.options) {
27306
+ const originTLSOptions = { ...userHttpsAgent.options };
27307
+ const callback = agent.callback;
27308
+ agent.callback = function axiosTunnelingAgentCallback(req, opts) {
27309
+ return callback.call(this, req, { ...originTLSOptions, ...opts });
27310
+ };
27311
+ }
27312
+ agent[kAxiosInstalledTunnel] = true;
27313
+ cache.set(key, agent);
27314
+ return agent;
27315
+ }
25844
27316
  var supportedProtocols = platform_default.protocols.map((protocol) => {
25845
27317
  return protocol + ":";
25846
27318
  });
@@ -25858,88 +27330,42 @@ var flushOnFinish = (stream4, [throttled, flush]) => {
25858
27330
  stream4.on("end", flush).on("error", flush);
25859
27331
  return throttled;
25860
27332
  };
25861
- var Http2Sessions = class {
25862
- constructor() {
25863
- this.sessions = /* @__PURE__ */ Object.create(null);
25864
- }
25865
- getSession(authority, options) {
25866
- options = Object.assign(
25867
- {
25868
- sessionTimeout: 1e3
25869
- },
25870
- options
25871
- );
25872
- let authoritySessions = this.sessions[authority];
25873
- if (authoritySessions) {
25874
- let len = authoritySessions.length;
25875
- for (let i = 0; i < len; i++) {
25876
- const [sessionHandle, sessionOptions] = authoritySessions[i];
25877
- if (!sessionHandle.destroyed && !sessionHandle.closed && import_util3.default.isDeepStrictEqual(sessionOptions, options)) {
25878
- return sessionHandle;
25879
- }
25880
- }
25881
- }
25882
- const session = import_http2.default.connect(authority, options);
25883
- let removed;
25884
- const removeSession = () => {
25885
- if (removed) {
25886
- return;
25887
- }
25888
- removed = true;
25889
- let entries = authoritySessions, len = entries.length, i = len;
25890
- while (i--) {
25891
- if (entries[i][0] === session) {
25892
- if (len === 1) {
25893
- delete this.sessions[authority];
25894
- } else {
25895
- entries.splice(i, 1);
25896
- }
25897
- if (!session.closed) {
25898
- session.close();
25899
- }
25900
- return;
25901
- }
25902
- }
25903
- };
25904
- const originalRequestFn = session.request;
25905
- const { sessionTimeout } = options;
25906
- if (sessionTimeout != null) {
25907
- let timer;
25908
- let streamsCount = 0;
25909
- session.request = function() {
25910
- const stream4 = originalRequestFn.apply(this, arguments);
25911
- streamsCount++;
25912
- if (timer) {
25913
- clearTimeout(timer);
25914
- timer = null;
25915
- }
25916
- stream4.once("close", () => {
25917
- if (!--streamsCount) {
25918
- timer = setTimeout(() => {
25919
- timer = null;
25920
- removeSession();
25921
- }, sessionTimeout);
25922
- }
25923
- });
25924
- return stream4;
25925
- };
25926
- }
25927
- session.once("close", removeSession);
25928
- let entry = [session, options];
25929
- authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
25930
- return session;
25931
- }
25932
- };
25933
- var http2Sessions = new Http2Sessions();
27333
+ var http2Sessions = new Http2Sessions_default();
25934
27334
  function dispatchBeforeRedirect(options, responseDetails, requestDetails) {
25935
27335
  if (options.beforeRedirects.proxy) {
25936
27336
  options.beforeRedirects.proxy(options);
25937
27337
  }
27338
+ if (options.beforeRedirects.auth) {
27339
+ options.beforeRedirects.auth(options);
27340
+ }
27341
+ if (options.beforeRedirects.sensitiveHeaders) {
27342
+ options.beforeRedirects.sensitiveHeaders(options, requestDetails);
27343
+ }
25938
27344
  if (options.beforeRedirects.config) {
25939
27345
  options.beforeRedirects.config(options, responseDetails, requestDetails);
25940
27346
  }
25941
27347
  }
25942
- function setProxy(options, configProxy, location, isRedirect) {
27348
+ function stripMatchingHeaders(headers, sensitiveSet) {
27349
+ if (!headers) {
27350
+ return;
27351
+ }
27352
+ Object.keys(headers).forEach((header) => {
27353
+ if (sensitiveSet.has(header.toLowerCase())) {
27354
+ delete headers[header];
27355
+ }
27356
+ });
27357
+ }
27358
+ function isSameOriginRedirect(redirectOptions, requestDetails) {
27359
+ if (!requestDetails) {
27360
+ return false;
27361
+ }
27362
+ try {
27363
+ return new URL(requestDetails.url).origin === new URL(redirectOptions.href).origin;
27364
+ } catch (e) {
27365
+ return false;
27366
+ }
27367
+ }
27368
+ function setProxy(options, configProxy, location, isRedirect, configHttpsAgent) {
25943
27369
  let proxy = configProxy;
25944
27370
  if (!proxy && proxy !== false) {
25945
27371
  const proxyUrl = getProxyForUrl(location);
@@ -25956,6 +27382,9 @@ function setProxy(options, configProxy, location, isRedirect) {
25956
27382
  }
25957
27383
  }
25958
27384
  }
27385
+ if (isRedirect && options.agent && options.agent[kAxiosInstalledTunnel]) {
27386
+ options.agent = void 0;
27387
+ }
25959
27388
  if (proxy) {
25960
27389
  const isProxyURL = proxy instanceof URL;
25961
27390
  const readProxyField = (key) => isProxyURL || utils_default.hasOwnProp(proxy, key) ? proxy[key] : void 0;
@@ -25975,31 +27404,61 @@ function setProxy(options, configProxy, location, isRedirect) {
25975
27404
  } else if (authIsObject) {
25976
27405
  throw new AxiosError_default("Invalid proxy authorization", AxiosError_default.ERR_BAD_OPTION, { proxy });
25977
27406
  }
25978
- const base64 = Buffer.from(proxyAuth, "utf8").toString("base64");
25979
- options.headers["Proxy-Authorization"] = "Basic " + base64;
25980
27407
  }
25981
- let hasUserHostHeader = false;
25982
- for (const name of Object.keys(options.headers)) {
25983
- if (name.toLowerCase() === "host") {
25984
- hasUserHostHeader = true;
25985
- break;
27408
+ const targetIsHttps = isHttps.test(options.protocol);
27409
+ if (targetIsHttps) {
27410
+ if (!(configHttpsAgent instanceof import_https_proxy_agent.default)) {
27411
+ const proxyHost = readProxyField("hostname") || readProxyField("host");
27412
+ const proxyPort = readProxyField("port");
27413
+ const rawProxyProtocol = readProxyField("protocol");
27414
+ const normalizedProtocol = rawProxyProtocol ? rawProxyProtocol.includes(":") ? rawProxyProtocol : `${rawProxyProtocol}:` : "http:";
27415
+ const proxyHostForURL = proxyHost && proxyHost.includes(":") && !proxyHost.startsWith("[") ? `[${proxyHost}]` : proxyHost;
27416
+ const proxyURL = new URL(
27417
+ `${normalizedProtocol}//${proxyHostForURL}${proxyPort ? ":" + proxyPort : ""}`
27418
+ );
27419
+ const agentOptions = {
27420
+ protocol: proxyURL.protocol,
27421
+ hostname: proxyURL.hostname.replace(/^\[|\]$/g, ""),
27422
+ port: proxyURL.port,
27423
+ auth: proxyAuth && typeof proxyAuth === "string" ? proxyAuth : void 0
27424
+ };
27425
+ if (proxyURL.protocol === "https:") {
27426
+ agentOptions.ALPNProtocols = ["http/1.1"];
27427
+ }
27428
+ const tunnelingAgent = getTunnelingAgent(agentOptions, configHttpsAgent);
27429
+ options.agent = tunnelingAgent;
27430
+ if (options.agents) {
27431
+ options.agents.https = tunnelingAgent;
27432
+ }
27433
+ }
27434
+ } else {
27435
+ if (proxyAuth) {
27436
+ const base64 = Buffer.from(proxyAuth, "utf8").toString("base64");
27437
+ options.headers["Proxy-Authorization"] = "Basic " + base64;
27438
+ }
27439
+ let hasUserHostHeader = false;
27440
+ for (const name of Object.keys(options.headers)) {
27441
+ if (name.toLowerCase() === "host") {
27442
+ hasUserHostHeader = true;
27443
+ break;
27444
+ }
27445
+ }
27446
+ if (!hasUserHostHeader) {
27447
+ options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
27448
+ }
27449
+ const proxyHost = readProxyField("hostname") || readProxyField("host");
27450
+ options.hostname = proxyHost;
27451
+ options.host = proxyHost;
27452
+ options.port = readProxyField("port");
27453
+ options.path = location;
27454
+ const proxyProtocol = readProxyField("protocol");
27455
+ if (proxyProtocol) {
27456
+ options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
25986
27457
  }
25987
- }
25988
- if (!hasUserHostHeader) {
25989
- options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
25990
- }
25991
- const proxyHost = readProxyField("hostname") || readProxyField("host");
25992
- options.hostname = proxyHost;
25993
- options.host = proxyHost;
25994
- options.port = readProxyField("port");
25995
- options.path = location;
25996
- const proxyProtocol = readProxyField("protocol");
25997
- if (proxyProtocol) {
25998
- options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
25999
27458
  }
26000
27459
  }
26001
27460
  options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
26002
- setProxy(redirectOptions, configProxy, redirectOptions.href, true);
27461
+ setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent);
26003
27462
  };
26004
27463
  }
26005
27464
  var isHttpAdapterSupported = typeof process !== "undefined" && utils_default.kindOf(process) === "process";
@@ -26038,7 +27497,7 @@ var http2Transport = {
26038
27497
  const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
26039
27498
  const { http2Options, headers } = options;
26040
27499
  const session = http2Sessions.getSession(authority, http2Options);
26041
- const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = import_http2.default.constants;
27500
+ const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = import_http22.default.constants;
26042
27501
  const http2Headers = {
26043
27502
  [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
26044
27503
  [HTTP2_HEADER_METHOD]: options.method,
@@ -26062,7 +27521,8 @@ var http2Transport = {
26062
27521
  };
26063
27522
  var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26064
27523
  return wrapAsync(async function dispatchHttpRequest(resolve3, reject, onDone) {
26065
- const own2 = (key) => utils_default.hasOwnProp(config, key) ? config[key] : void 0;
27524
+ const own2 = (key) => utils_default.getSafeProp(config, key);
27525
+ const transitional2 = own2("transitional") || transitional_default;
26066
27526
  let data = own2("data");
26067
27527
  let lookup = own2("lookup");
26068
27528
  let family = own2("family");
@@ -26071,7 +27531,13 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26071
27531
  let http2Options = own2("http2Options");
26072
27532
  const responseType = own2("responseType");
26073
27533
  const responseEncoding = own2("responseEncoding");
26074
- const method = config.method.toUpperCase();
27534
+ const httpAgent = own2("httpAgent");
27535
+ const httpsAgent = own2("httpsAgent");
27536
+ const method = own2("method").toUpperCase();
27537
+ const maxRedirects = own2("maxRedirects");
27538
+ const maxBodyLength = own2("maxBodyLength");
27539
+ const maxContentLength = own2("maxContentLength");
27540
+ const decompress = own2("decompress");
26075
27541
  let isDone;
26076
27542
  let rejected = false;
26077
27543
  let req;
@@ -26104,7 +27570,6 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26104
27570
  !reason || reason.type ? new CanceledError_default(null, config, req) : reason
26105
27571
  );
26106
27572
  } catch (err) {
26107
- console.warn("emit error", err);
26108
27573
  }
26109
27574
  }
26110
27575
  function clearConnectPhaseTimer() {
@@ -26114,10 +27579,11 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26114
27579
  }
26115
27580
  }
26116
27581
  function createTimeoutError() {
26117
- let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
26118
- const transitional2 = config.transitional || transitional_default;
26119
- if (config.timeoutErrorMessage) {
26120
- timeoutErrorMessage = config.timeoutErrorMessage;
27582
+ const configTimeout = own2("timeout");
27583
+ let timeoutErrorMessage = configTimeout ? "timeout of " + configTimeout + "ms exceeded" : "timeout exceeded";
27584
+ const configTimeoutErrorMessage = own2("timeoutErrorMessage");
27585
+ if (configTimeoutErrorMessage) {
27586
+ timeoutErrorMessage = configTimeoutErrorMessage;
26121
27587
  }
26122
27588
  return new AxiosError_default(
26123
27589
  timeoutErrorMessage,
@@ -26161,17 +27627,17 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26161
27627
  onFinished();
26162
27628
  }
26163
27629
  });
26164
- const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
27630
+ const fullPath = buildFullPath(own2("baseURL"), own2("url"), own2("allowAbsoluteUrls"), config);
26165
27631
  const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : void 0);
26166
27632
  const protocol = parsed.protocol || supportedProtocols[0];
26167
27633
  if (protocol === "data:") {
26168
- if (config.maxContentLength > -1) {
26169
- const dataUrl = String(config.url || fullPath || "");
27634
+ if (maxContentLength > -1) {
27635
+ const dataUrl = String(own2("url") || fullPath || "");
26170
27636
  const estimated = estimateDataURLDecodedBytes(dataUrl);
26171
- if (estimated > config.maxContentLength) {
27637
+ if (estimated > maxContentLength) {
26172
27638
  return reject(
26173
27639
  new AxiosError_default(
26174
- "maxContentLength size of " + config.maxContentLength + " exceeded",
27640
+ "maxContentLength size of " + maxContentLength + " exceeded",
26175
27641
  AxiosError_default.ERR_BAD_RESPONSE,
26176
27642
  config
26177
27643
  )
@@ -26188,7 +27654,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26188
27654
  });
26189
27655
  }
26190
27656
  try {
26191
- convertedData = fromDataURI(config.url, responseType === "blob", {
27657
+ convertedData = fromDataURI(own2("url"), responseType === "blob", {
26192
27658
  Blob: config.env && config.env.Blob
26193
27659
  });
26194
27660
  } catch (err) {
@@ -26237,7 +27703,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26237
27703
  setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
26238
27704
  if (!headers.hasContentLength()) {
26239
27705
  try {
26240
- const knownLength = await import_util3.default.promisify(data.getLength).call(data);
27706
+ const knownLength = await import_util4.default.promisify(data.getLength).call(data);
26241
27707
  Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
26242
27708
  } catch (e) {
26243
27709
  }
@@ -26262,7 +27728,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26262
27728
  );
26263
27729
  }
26264
27730
  headers.setContentLength(data.length, false);
26265
- if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
27731
+ if (maxBodyLength > -1 && data.length > maxBodyLength) {
26266
27732
  return reject(
26267
27733
  new AxiosError_default(
26268
27734
  "Request body larger than maxBodyLength limit",
@@ -26306,11 +27772,11 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26306
27772
  let auth = void 0;
26307
27773
  const configAuth = own2("auth");
26308
27774
  if (configAuth) {
26309
- const username = configAuth.username || "";
26310
- const password = configAuth.password || "";
27775
+ const username = utils_default.getSafeProp(configAuth, "username") || "";
27776
+ const password = utils_default.getSafeProp(configAuth, "password") || "";
26311
27777
  auth = username + ":" + password;
26312
27778
  }
26313
- if (!auth && parsed.username) {
27779
+ if (!auth && (parsed.username || parsed.password)) {
26314
27780
  const urlUsername = decodeURIComponentSafe(parsed.username);
26315
27781
  const urlPassword = decodeURIComponentSafe(parsed.password);
26316
27782
  auth = urlUsername + ":" + urlPassword;
@@ -26320,26 +27786,26 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26320
27786
  try {
26321
27787
  path = buildURL(
26322
27788
  parsed.pathname + parsed.search,
26323
- config.params,
26324
- config.paramsSerializer
27789
+ own2("params"),
27790
+ own2("paramsSerializer")
26325
27791
  ).replace(/^\?/, "");
26326
27792
  } catch (err) {
26327
27793
  const customErr = new Error(err.message);
26328
27794
  customErr.config = config;
26329
- customErr.url = config.url;
27795
+ customErr.url = own2("url");
26330
27796
  customErr.exists = true;
26331
27797
  return reject(customErr);
26332
27798
  }
26333
27799
  headers.set(
26334
27800
  "Accept-Encoding",
26335
- "gzip, compress, deflate" + (isBrotliSupported ? ", br" : ""),
27801
+ utils_default.hasOwnProp(transitional2, "advertiseZstdAcceptEncoding") && transitional2.advertiseZstdAcceptEncoding === true ? ACCEPT_ENCODING_WITH_ZSTD : ACCEPT_ENCODING,
26336
27802
  false
26337
27803
  );
26338
27804
  const options = Object.assign(/* @__PURE__ */ Object.create(null), {
26339
27805
  path,
26340
27806
  method,
26341
- headers: headers.toJSON(),
26342
- agents: { http: config.httpAgent, https: config.httpsAgent },
27807
+ headers: toByteStringHeaderObject(headers),
27808
+ agents: { http: httpAgent, https: httpsAgent },
26343
27809
  auth,
26344
27810
  protocol,
26345
27811
  family,
@@ -26348,64 +27814,118 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26348
27814
  http2Options
26349
27815
  });
26350
27816
  !utils_default.isUndefined(lookup) && (options.lookup = lookup);
26351
- if (config.socketPath) {
26352
- if (typeof config.socketPath !== "string") {
27817
+ const socketPath = own2("socketPath");
27818
+ if (socketPath) {
27819
+ if (typeof socketPath !== "string") {
26353
27820
  return reject(
26354
27821
  new AxiosError_default("socketPath must be a string", AxiosError_default.ERR_BAD_OPTION_VALUE, config)
26355
27822
  );
26356
27823
  }
26357
- if (config.allowedSocketPaths != null) {
26358
- const allowed = Array.isArray(config.allowedSocketPaths) ? config.allowedSocketPaths : [config.allowedSocketPaths];
26359
- const resolvedSocket = (0, import_path.resolve)(config.socketPath);
27824
+ const allowedSocketPaths = own2("allowedSocketPaths");
27825
+ if (allowedSocketPaths != null) {
27826
+ const allowed = Array.isArray(allowedSocketPaths) ? allowedSocketPaths : [allowedSocketPaths];
27827
+ const resolvedSocket = (0, import_path.resolve)(socketPath);
26360
27828
  const isAllowed = allowed.some(
26361
27829
  (entry) => typeof entry === "string" && (0, import_path.resolve)(entry) === resolvedSocket
26362
27830
  );
26363
27831
  if (!isAllowed) {
26364
27832
  return reject(
26365
27833
  new AxiosError_default(
26366
- `socketPath "${config.socketPath}" is not permitted by allowedSocketPaths`,
27834
+ `socketPath "${socketPath}" is not permitted by allowedSocketPaths`,
26367
27835
  AxiosError_default.ERR_BAD_OPTION_VALUE,
26368
27836
  config
26369
27837
  )
26370
27838
  );
26371
27839
  }
26372
27840
  }
26373
- options.socketPath = config.socketPath;
27841
+ options.socketPath = socketPath;
26374
27842
  } else {
26375
27843
  options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
26376
27844
  options.port = parsed.port;
26377
27845
  setProxy(
26378
27846
  options,
26379
- config.proxy,
26380
- protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path
27847
+ own2("proxy"),
27848
+ protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path,
27849
+ false,
27850
+ httpsAgent
26381
27851
  );
26382
27852
  }
26383
27853
  let transport;
26384
27854
  let isNativeTransport = false;
27855
+ let transportEnforcesMaxBodyLength = false;
26385
27856
  const isHttpsRequest = isHttps.test(options.protocol);
26386
- options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
27857
+ if (options.agent == null) {
27858
+ options.agent = isHttpsRequest ? httpsAgent : httpAgent;
27859
+ }
26387
27860
  if (isHttp2) {
26388
27861
  transport = http2Transport;
26389
27862
  } else {
26390
27863
  const configTransport = own2("transport");
26391
27864
  if (configTransport) {
26392
27865
  transport = configTransport;
26393
- } else if (config.maxRedirects === 0) {
27866
+ } else if (maxRedirects === 0) {
26394
27867
  transport = isHttpsRequest ? import_https.default : import_http.default;
26395
27868
  isNativeTransport = true;
26396
27869
  } else {
26397
- if (config.maxRedirects) {
26398
- options.maxRedirects = config.maxRedirects;
27870
+ transportEnforcesMaxBodyLength = true;
27871
+ options.sensitiveHeaders = [];
27872
+ if (maxRedirects) {
27873
+ options.maxRedirects = maxRedirects;
26399
27874
  }
26400
27875
  const configBeforeRedirect = own2("beforeRedirect");
26401
27876
  if (configBeforeRedirect) {
26402
27877
  options.beforeRedirects.config = configBeforeRedirect;
26403
27878
  }
27879
+ if (auth) {
27880
+ const requestOrigin = parsed.origin;
27881
+ const authToRestore = auth;
27882
+ options.beforeRedirects.auth = function beforeRedirectAuth(redirectOptions) {
27883
+ try {
27884
+ if (new URL(redirectOptions.href).origin === requestOrigin) {
27885
+ redirectOptions.auth = authToRestore;
27886
+ }
27887
+ } catch (e) {
27888
+ }
27889
+ };
27890
+ }
27891
+ const sensitiveHeaders = own2("sensitiveHeaders");
27892
+ if (sensitiveHeaders != null) {
27893
+ if (!utils_default.isArray(sensitiveHeaders)) {
27894
+ return reject(
27895
+ new AxiosError_default(
27896
+ "sensitiveHeaders must be an array of strings",
27897
+ AxiosError_default.ERR_BAD_OPTION_VALUE,
27898
+ config
27899
+ )
27900
+ );
27901
+ }
27902
+ const sensitiveSet = /* @__PURE__ */ new Set();
27903
+ for (const header of sensitiveHeaders) {
27904
+ if (!utils_default.isString(header)) {
27905
+ return reject(
27906
+ new AxiosError_default(
27907
+ "sensitiveHeaders must be an array of strings",
27908
+ AxiosError_default.ERR_BAD_OPTION_VALUE,
27909
+ config
27910
+ )
27911
+ );
27912
+ }
27913
+ sensitiveSet.add(header.toLowerCase());
27914
+ }
27915
+ if (sensitiveSet.size) {
27916
+ options.sensitiveHeaders = Array.from(sensitiveSet);
27917
+ options.beforeRedirects.sensitiveHeaders = function beforeRedirectSensitiveHeaders(redirectOptions, requestDetails) {
27918
+ if (!isSameOriginRedirect(redirectOptions, requestDetails)) {
27919
+ stripMatchingHeaders(redirectOptions.headers, sensitiveSet);
27920
+ }
27921
+ };
27922
+ }
27923
+ }
26404
27924
  transport = isHttpsRequest ? httpsFollow : httpFollow;
26405
27925
  }
26406
27926
  }
26407
- if (config.maxBodyLength > -1) {
26408
- options.maxBodyLength = config.maxBodyLength;
27927
+ if (maxBodyLength > -1) {
27928
+ options.maxBodyLength = maxBodyLength;
26409
27929
  } else {
26410
27930
  options.maxBodyLength = Infinity;
26411
27931
  }
@@ -26433,7 +27953,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26433
27953
  }
26434
27954
  let responseStream = res;
26435
27955
  const lastRequest = res.req || req;
26436
- if (config.decompress !== false && res.headers["content-encoding"]) {
27956
+ if (decompress !== false && res.headers["content-encoding"]) {
26437
27957
  if (method === "HEAD" || res.statusCode === 204) {
26438
27958
  delete res.headers["content-encoding"];
26439
27959
  }
@@ -26456,6 +27976,13 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26456
27976
  streams.push(import_zlib.default.createBrotliDecompress(brotliOptions));
26457
27977
  delete res.headers["content-encoding"];
26458
27978
  }
27979
+ break;
27980
+ case "zstd":
27981
+ if (isZstdSupported) {
27982
+ streams.push(import_zlib.default.createZstdDecompress(zstdOptions));
27983
+ delete res.headers["content-encoding"];
27984
+ }
27985
+ break;
26459
27986
  }
26460
27987
  }
26461
27988
  responseStream = streams.length > 1 ? import_stream5.default.pipeline(streams, utils_default.noop) : streams[0];
@@ -26467,8 +27994,8 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26467
27994
  request: lastRequest
26468
27995
  };
26469
27996
  if (responseType === "stream") {
26470
- if (config.maxContentLength > -1) {
26471
- const limit = config.maxContentLength;
27997
+ if (maxContentLength > -1) {
27998
+ const limit = maxContentLength;
26472
27999
  const source = responseStream;
26473
28000
  async function* enforceMaxContentLength() {
26474
28001
  let totalResponseBytes = 0;
@@ -26497,12 +28024,12 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26497
28024
  responseStream.on("data", function handleStreamData(chunk) {
26498
28025
  responseBuffer.push(chunk);
26499
28026
  totalResponseBytes += chunk.length;
26500
- if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
28027
+ if (maxContentLength > -1 && totalResponseBytes > maxContentLength) {
26501
28028
  rejected = true;
26502
28029
  responseStream.destroy();
26503
28030
  abort(
26504
28031
  new AxiosError_default(
26505
- "maxContentLength size of " + config.maxContentLength + " exceeded",
28032
+ "maxContentLength size of " + maxContentLength + " exceeded",
26506
28033
  AxiosError_default.ERR_BAD_RESPONSE,
26507
28034
  config,
26508
28035
  lastRequest
@@ -26585,8 +28112,8 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26585
28112
  }
26586
28113
  boundSockets.clear();
26587
28114
  });
26588
- if (config.timeout) {
26589
- const timeout = parseInt(config.timeout, 10);
28115
+ if (own2("timeout")) {
28116
+ const timeout = parseInt(own2("timeout"), 10);
26590
28117
  if (Number.isNaN(timeout)) {
26591
28118
  abort(
26592
28119
  new AxiosError_default(
@@ -26625,8 +28152,8 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
26625
28152
  }
26626
28153
  });
26627
28154
  let uploadStream = data;
26628
- if (config.maxBodyLength > -1 && config.maxRedirects === 0) {
26629
- const limit = config.maxBodyLength;
28155
+ if (maxBodyLength > -1 && !transportEnforcesMaxBodyLength) {
28156
+ const limit = maxBodyLength;
26630
28157
  let bytesSent = 0;
26631
28158
  uploadStream = import_stream5.default.pipeline(
26632
28159
  [
@@ -26767,6 +28294,23 @@ function mergeConfig(config1, config2) {
26767
28294
  return getMergedValue(void 0, a);
26768
28295
  }
26769
28296
  }
28297
+ function getMergedTransitionalOption(prop) {
28298
+ const transitional2 = utils_default.hasOwnProp(config2, "transitional") ? config2.transitional : void 0;
28299
+ if (!utils_default.isUndefined(transitional2)) {
28300
+ if (utils_default.isPlainObject(transitional2)) {
28301
+ if (utils_default.hasOwnProp(transitional2, prop)) {
28302
+ return transitional2[prop];
28303
+ }
28304
+ } else {
28305
+ return void 0;
28306
+ }
28307
+ }
28308
+ const transitional1 = utils_default.hasOwnProp(config1, "transitional") ? config1.transitional : void 0;
28309
+ if (utils_default.isPlainObject(transitional1) && utils_default.hasOwnProp(transitional1, prop)) {
28310
+ return transitional1[prop];
28311
+ }
28312
+ return void 0;
28313
+ }
26770
28314
  function mergeDirectKeys(a, b, prop) {
26771
28315
  if (utils_default.hasOwnProp(config2, prop)) {
26772
28316
  return getMergedValue(a, b);
@@ -26814,6 +28358,13 @@ function mergeConfig(config1, config2) {
26814
28358
  const configValue = merge2(a, b, prop);
26815
28359
  utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
26816
28360
  });
28361
+ if (utils_default.hasOwnProp(config2, "validateStatus") && utils_default.isUndefined(config2.validateStatus) && getMergedTransitionalOption("validateStatusUndefinedResolves") === false) {
28362
+ if (utils_default.hasOwnProp(config1, "validateStatus")) {
28363
+ config.validateStatus = getMergedValue(void 0, config1.validateStatus);
28364
+ } else {
28365
+ delete config.validateStatus;
28366
+ }
28367
+ }
26817
28368
  return config;
26818
28369
  }
26819
28370
 
@@ -26834,7 +28385,7 @@ var encodeUTF8 = (str) => encodeURIComponent(str).replace(
26834
28385
  /%([0-9A-F]{2})/gi,
26835
28386
  (_, hex) => String.fromCharCode(parseInt(hex, 16))
26836
28387
  );
26837
- var resolveConfig_default = (config) => {
28388
+ function resolveConfig(config) {
26838
28389
  const newConfig = mergeConfig({}, config);
26839
28390
  const own2 = (key) => utils_default.hasOwnProp(newConfig, key) ? newConfig[key] : void 0;
26840
28391
  const data = own2("data");
@@ -26848,18 +28399,20 @@ var resolveConfig_default = (config) => {
26848
28399
  const url2 = own2("url");
26849
28400
  newConfig.headers = headers = AxiosHeaders_default.from(headers);
26850
28401
  newConfig.url = buildURL(
26851
- buildFullPath(baseURL, url2, allowAbsoluteUrls),
26852
- config.params,
26853
- config.paramsSerializer
28402
+ buildFullPath(baseURL, url2, allowAbsoluteUrls, newConfig),
28403
+ own2("params"),
28404
+ own2("paramsSerializer")
26854
28405
  );
26855
28406
  if (auth) {
28407
+ const username = utils_default.getSafeProp(auth, "username") || "";
28408
+ const password = utils_default.getSafeProp(auth, "password") || "";
26856
28409
  headers.set(
26857
28410
  "Authorization",
26858
- "Basic " + btoa((auth.username || "") + ":" + (auth.password ? encodeUTF8(auth.password) : ""))
28411
+ "Basic " + btoa(username + ":" + (password ? encodeUTF8(password) : ""))
26859
28412
  );
26860
28413
  }
26861
28414
  if (utils_default.isFormData(data)) {
26862
- if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
28415
+ if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv || utils_default.isReactNative(data)) {
26863
28416
  headers.setContentType(void 0);
26864
28417
  } else if (utils_default.isFunction(data.getHeaders)) {
26865
28418
  setFormDataHeaders2(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
@@ -26878,7 +28431,8 @@ var resolveConfig_default = (config) => {
26878
28431
  }
26879
28432
  }
26880
28433
  return newConfig;
26881
- };
28434
+ }
28435
+ var resolveConfig_default = resolveConfig;
26882
28436
 
26883
28437
  // ../../../node_modules/axios/lib/adapters/xhr.js
26884
28438
  var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
@@ -26977,7 +28531,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
26977
28531
  };
26978
28532
  requestData === void 0 && requestHeaders.setContentType(null);
26979
28533
  if ("setRequestHeader" in request) {
26980
- utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
28534
+ utils_default.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {
26981
28535
  request.setRequestHeader(key, val);
26982
28536
  });
26983
28537
  }
@@ -27028,39 +28582,41 @@ var xhr_default = isXHRAdapterSupported && function(config) {
27028
28582
 
27029
28583
  // ../../../node_modules/axios/lib/helpers/composeSignals.js
27030
28584
  var composeSignals = (signals2, timeout) => {
27031
- const { length } = signals2 = signals2 ? signals2.filter(Boolean) : [];
27032
- if (timeout || length) {
27033
- let controller = new AbortController();
27034
- let aborted;
27035
- const onabort = function(reason) {
27036
- if (!aborted) {
27037
- aborted = true;
27038
- unsubscribe();
27039
- const err = reason instanceof Error ? reason : this.reason;
27040
- controller.abort(
27041
- err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err)
27042
- );
27043
- }
27044
- };
27045
- let timer = timeout && setTimeout(() => {
27046
- timer = null;
27047
- onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
27048
- }, timeout);
27049
- const unsubscribe = () => {
27050
- if (signals2) {
27051
- timer && clearTimeout(timer);
27052
- timer = null;
27053
- signals2.forEach((signal2) => {
27054
- signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
27055
- });
27056
- signals2 = null;
27057
- }
27058
- };
27059
- signals2.forEach((signal2) => signal2.addEventListener("abort", onabort));
27060
- const { signal } = controller;
27061
- signal.unsubscribe = () => utils_default.asap(unsubscribe);
27062
- return signal;
28585
+ signals2 = signals2 ? signals2.filter(Boolean) : [];
28586
+ if (!timeout && !signals2.length) {
28587
+ return;
27063
28588
  }
28589
+ const controller = new AbortController();
28590
+ let aborted = false;
28591
+ const onabort = function(reason) {
28592
+ if (!aborted) {
28593
+ aborted = true;
28594
+ unsubscribe();
28595
+ const err = reason instanceof Error ? reason : this.reason;
28596
+ controller.abort(
28597
+ err instanceof AxiosError_default ? err : new CanceledError_default(err instanceof Error ? err.message : err)
28598
+ );
28599
+ }
28600
+ };
28601
+ let timer = timeout && setTimeout(() => {
28602
+ timer = null;
28603
+ onabort(new AxiosError_default(`timeout of ${timeout}ms exceeded`, AxiosError_default.ETIMEDOUT));
28604
+ }, timeout);
28605
+ const unsubscribe = () => {
28606
+ if (!signals2) {
28607
+ return;
28608
+ }
28609
+ timer && clearTimeout(timer);
28610
+ timer = null;
28611
+ signals2.forEach((signal2) => {
28612
+ signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
28613
+ });
28614
+ signals2 = null;
28615
+ };
28616
+ signals2.forEach((signal2) => signal2.addEventListener("abort", onabort));
28617
+ const { signal } = controller;
28618
+ signal.unsubscribe = () => utils_default.asap(unsubscribe);
28619
+ return signal;
27064
28620
  };
27065
28621
  var composeSignals_default = composeSignals;
27066
28622
 
@@ -27147,6 +28703,20 @@ var trackStream = (stream4, chunkSize, onProgress, onFinish) => {
27147
28703
  // ../../../node_modules/axios/lib/adapters/fetch.js
27148
28704
  var DEFAULT_CHUNK_SIZE = 64 * 1024;
27149
28705
  var { isFunction: isFunction2 } = utils_default;
28706
+ var encodeUTF82 = (str) => encodeURIComponent(str).replace(
28707
+ /%([0-9A-F]{2})/gi,
28708
+ (_, hex) => String.fromCharCode(parseInt(hex, 16))
28709
+ );
28710
+ var decodeURIComponentSafe2 = (value) => {
28711
+ if (!utils_default.isString(value)) {
28712
+ return value;
28713
+ }
28714
+ try {
28715
+ return decodeURIComponent(value);
28716
+ } catch (error) {
28717
+ return value;
28718
+ }
28719
+ };
27150
28720
  var test = (fn, ...args2) => {
27151
28721
  try {
27152
28722
  return !!fn(...args2);
@@ -27154,8 +28724,16 @@ var test = (fn, ...args2) => {
27154
28724
  return false;
27155
28725
  }
27156
28726
  };
28727
+ var maybeWithAuthCredentials = (url2) => {
28728
+ const protocolIndex = url2.indexOf("://");
28729
+ let urlToCheck = url2;
28730
+ if (protocolIndex !== -1) {
28731
+ urlToCheck = urlToCheck.slice(protocolIndex + 3);
28732
+ }
28733
+ return urlToCheck.includes("@") || urlToCheck.includes(":");
28734
+ };
27157
28735
  var factory = (env3) => {
27158
- const globalObject = utils_default.global ?? globalThis;
28736
+ const globalObject = utils_default.global !== void 0 && utils_default.global !== null ? utils_default.global : globalThis;
27159
28737
  const { ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = globalObject;
27160
28738
  env3 = utils_default.merge.call(
27161
28739
  {
@@ -27258,6 +28836,7 @@ var factory = (env3) => {
27258
28836
  } = resolveConfig_default(config);
27259
28837
  const hasMaxContentLength = utils_default.isNumber(maxContentLength) && maxContentLength > -1;
27260
28838
  const hasMaxBodyLength = utils_default.isNumber(maxBodyLength) && maxBodyLength > -1;
28839
+ const own2 = (key) => utils_default.hasOwnProp(config, key) ? config[key] : void 0;
27261
28840
  let _fetch = envFetch || fetch;
27262
28841
  responseType = responseType ? (responseType + "").toLowerCase() : "text";
27263
28842
  let composedSignal = composeSignals_default(
@@ -27269,7 +28848,47 @@ var factory = (env3) => {
27269
28848
  composedSignal.unsubscribe();
27270
28849
  });
27271
28850
  let requestContentLength;
28851
+ let pendingBodyError = null;
28852
+ const maxBodyLengthError = () => new AxiosError_default(
28853
+ "Request body larger than maxBodyLength limit",
28854
+ AxiosError_default.ERR_BAD_REQUEST,
28855
+ config,
28856
+ request
28857
+ );
27272
28858
  try {
28859
+ let auth = void 0;
28860
+ const configAuth = own2("auth");
28861
+ if (configAuth) {
28862
+ const username = utils_default.getSafeProp(configAuth, "username") || "";
28863
+ const password = utils_default.getSafeProp(configAuth, "password") || "";
28864
+ auth = {
28865
+ username,
28866
+ password
28867
+ };
28868
+ }
28869
+ if (maybeWithAuthCredentials(url2)) {
28870
+ const parsedURL = new URL(url2, platform_default.origin);
28871
+ if (!auth && (parsedURL.username || parsedURL.password)) {
28872
+ const urlUsername = decodeURIComponentSafe2(parsedURL.username);
28873
+ const urlPassword = decodeURIComponentSafe2(parsedURL.password);
28874
+ auth = {
28875
+ username: urlUsername,
28876
+ password: urlPassword
28877
+ };
28878
+ }
28879
+ if (parsedURL.username || parsedURL.password) {
28880
+ parsedURL.username = "";
28881
+ parsedURL.password = "";
28882
+ url2 = parsedURL.href;
28883
+ }
28884
+ }
28885
+ if (auth) {
28886
+ headers.delete("authorization");
28887
+ headers.set(
28888
+ "Authorization",
28889
+ "Basic " + btoa(encodeUTF82((auth.username || "") + ":" + (auth.password || "")))
28890
+ );
28891
+ }
27273
28892
  if (hasMaxContentLength && typeof url2 === "string" && url2.startsWith("data:")) {
27274
28893
  const estimated = estimateDataURLDecodedBytes(url2);
27275
28894
  if (estimated > maxContentLength) {
@@ -27282,33 +28901,55 @@ var factory = (env3) => {
27282
28901
  }
27283
28902
  }
27284
28903
  if (hasMaxBodyLength && method !== "get" && method !== "head") {
27285
- const outboundLength = await resolveBodyLength(headers, data);
27286
- if (typeof outboundLength === "number" && isFinite(outboundLength) && outboundLength > maxBodyLength) {
27287
- throw new AxiosError_default(
27288
- "Request body larger than maxBodyLength limit",
27289
- AxiosError_default.ERR_BAD_REQUEST,
27290
- config,
27291
- request
27292
- );
28904
+ const outboundLength = await getBodyLength(data);
28905
+ if (typeof outboundLength === "number" && isFinite(outboundLength)) {
28906
+ requestContentLength = outboundLength;
28907
+ if (outboundLength > maxBodyLength) {
28908
+ throw maxBodyLengthError();
28909
+ }
27293
28910
  }
27294
28911
  }
27295
- if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
27296
- let _request = new Request(url2, {
27297
- method: "POST",
27298
- body: data,
27299
- duplex: "half"
27300
- });
27301
- let contentTypeHeader;
27302
- if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
27303
- headers.setContentType(contentTypeHeader);
27304
- }
27305
- if (_request.body) {
27306
- const [onProgress, flush] = progressEventDecorator(
27307
- requestContentLength,
27308
- progressEventReducer(asyncDecorator(onUploadProgress))
27309
- );
27310
- data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
28912
+ const mustEnforceStreamBody = hasMaxBodyLength && (utils_default.isReadableStream(data) || utils_default.isStream(data));
28913
+ const trackRequestStream = (stream4, onProgress, flush) => trackStream(
28914
+ stream4,
28915
+ DEFAULT_CHUNK_SIZE,
28916
+ (loadedBytes) => {
28917
+ if (hasMaxBodyLength && loadedBytes > maxBodyLength) {
28918
+ throw pendingBodyError = maxBodyLengthError();
28919
+ }
28920
+ onProgress && onProgress(loadedBytes);
28921
+ },
28922
+ flush
28923
+ );
28924
+ if (supportsRequestStream && method !== "get" && method !== "head" && (onUploadProgress || mustEnforceStreamBody)) {
28925
+ requestContentLength = requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;
28926
+ if (requestContentLength !== 0 || mustEnforceStreamBody) {
28927
+ let _request = new Request(url2, {
28928
+ method: "POST",
28929
+ body: data,
28930
+ duplex: "half"
28931
+ });
28932
+ let contentTypeHeader;
28933
+ if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
28934
+ headers.setContentType(contentTypeHeader);
28935
+ }
28936
+ if (_request.body) {
28937
+ const [onProgress, flush] = onUploadProgress && progressEventDecorator(
28938
+ requestContentLength,
28939
+ progressEventReducer(asyncDecorator(onUploadProgress))
28940
+ ) || [];
28941
+ data = trackRequestStream(_request.body, onProgress, flush);
28942
+ }
27311
28943
  }
28944
+ } else if (mustEnforceStreamBody && !isRequestSupported && isReadableStreamSupported && method !== "get" && method !== "head") {
28945
+ data = trackRequestStream(data);
28946
+ } else if (mustEnforceStreamBody && isRequestSupported && !supportsRequestStream && method !== "get" && method !== "head") {
28947
+ throw new AxiosError_default(
28948
+ "Stream request bodies are not supported by the current fetch implementation",
28949
+ AxiosError_default.ERR_NOT_SUPPORT,
28950
+ config,
28951
+ request
28952
+ );
27312
28953
  }
27313
28954
  if (!utils_default.isString(withCredentials)) {
27314
28955
  withCredentials = withCredentials ? "include" : "omit";
@@ -27325,15 +28966,16 @@ var factory = (env3) => {
27325
28966
  ...fetchOptions,
27326
28967
  signal: composedSignal,
27327
28968
  method: method.toUpperCase(),
27328
- headers: headers.normalize().toJSON(),
28969
+ headers: toByteStringHeaderObject(headers.normalize()),
27329
28970
  body: data,
27330
28971
  duplex: "half",
27331
28972
  credentials: isCredentialsSupported ? withCredentials : void 0
27332
28973
  };
27333
28974
  request = isRequestSupported && new Request(url2, resolvedOptions);
27334
28975
  let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url2, resolvedOptions));
28976
+ const responseHeaders = AxiosHeaders_default.from(response.headers);
27335
28977
  if (hasMaxContentLength) {
27336
- const declaredLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
28978
+ const declaredLength = utils_default.toFiniteNumber(responseHeaders.getContentLength());
27337
28979
  if (declaredLength != null && declaredLength > maxContentLength) {
27338
28980
  throw new AxiosError_default(
27339
28981
  "maxContentLength size of " + maxContentLength + " exceeded",
@@ -27349,7 +28991,7 @@ var factory = (env3) => {
27349
28991
  ["status", "statusText", "headers"].forEach((prop) => {
27350
28992
  options[prop] = response[prop];
27351
28993
  });
27352
- const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
28994
+ const responseContentLength = utils_default.toFiniteNumber(responseHeaders.getContentLength());
27353
28995
  const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
27354
28996
  responseContentLength,
27355
28997
  progressEventReducer(asyncDecorator(onDownloadProgress), true)
@@ -27422,6 +29064,14 @@ var factory = (env3) => {
27422
29064
  err !== canceledError && (canceledError.cause = err);
27423
29065
  throw canceledError;
27424
29066
  }
29067
+ if (pendingBodyError) {
29068
+ request && !pendingBodyError.request && (pendingBodyError.request = request);
29069
+ throw pendingBodyError;
29070
+ }
29071
+ if (err instanceof AxiosError_default) {
29072
+ request && !err.request && (err.request = request);
29073
+ throw err;
29074
+ }
27425
29075
  if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
27426
29076
  throw Object.assign(
27427
29077
  new AxiosError_default(
@@ -27704,7 +29354,9 @@ var Axios = class {
27704
29354
  silentJSONParsing: validators2.transitional(validators2.boolean),
27705
29355
  forcedJSONParsing: validators2.transitional(validators2.boolean),
27706
29356
  clarifyTimeoutError: validators2.transitional(validators2.boolean),
27707
- legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean)
29357
+ legacyInterceptorReqResOrdering: validators2.transitional(validators2.boolean),
29358
+ advertiseZstdAcceptEncoding: validators2.transitional(validators2.boolean),
29359
+ validateStatusUndefinedResolves: validators2.transitional(validators2.boolean)
27708
29360
  },
27709
29361
  false
27710
29362
  );
@@ -27804,7 +29456,7 @@ var Axios = class {
27804
29456
  }
27805
29457
  getUri(config) {
27806
29458
  config = mergeConfig(this.defaults, config);
27807
- const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
29459
+ const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls, config);
27808
29460
  return buildURL(fullPath, config.params, config.paramsSerializer);
27809
29461
  }
27810
29462
  };
@@ -27814,7 +29466,7 @@ utils_default.forEach(["delete", "get", "head", "options"], function forEachMeth
27814
29466
  mergeConfig(config || {}, {
27815
29467
  method,
27816
29468
  url: url2,
27817
- data: (config || {}).data
29469
+ data: config && utils_default.hasOwnProp(config, "data") ? config.data : void 0
27818
29470
  })
27819
29471
  );
27820
29472
  };