publish-microfrontend 1.11.2-beta.2c397c2 → 1.11.2-beta.5e5c12e
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.
- package/lib/index.js +1956 -304
- 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
|
|
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.__ ||
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
9243
|
-
if (typeof
|
|
9244
|
-
module2.exports =
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
|
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 =
|
|
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
|
|
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
|
|
22260
|
+
var require_node2 = __commonJS({
|
|
21048
22261
|
"../../../node_modules/debug/src/node.js"(exports2, module2) {
|
|
21049
22262
|
var tty3 = require("tty");
|
|
21050
|
-
var
|
|
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
|
-
|
|
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
|
|
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
|
|
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(
|
|
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
|
|
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 =
|
|
22383
|
+
module2.exports = require_browser2();
|
|
21171
22384
|
} else {
|
|
21172
|
-
module2.exports =
|
|
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 =
|
|
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 (
|
|
24930
|
+
if (!isObject(val)) {
|
|
23701
24931
|
return false;
|
|
23702
24932
|
}
|
|
23703
24933
|
const prototype2 = getPrototypeOf(val);
|
|
23704
|
-
return (prototype2 === null || prototype2 === Object.prototype ||
|
|
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
|
-
|
|
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
|
|
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
|
|
23995
|
-
const visit = (source
|
|
25241
|
+
const visited = /* @__PURE__ */ new WeakSet();
|
|
25242
|
+
const visit = (source) => {
|
|
23996
25243
|
if (isObject(source)) {
|
|
23997
|
-
if (
|
|
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
|
-
|
|
25251
|
+
visited.add(source);
|
|
24005
25252
|
const target = isArray(source) ? [] : {};
|
|
24006
25253
|
forEach(source, (value, key) => {
|
|
24007
|
-
const reducedValue = visit(value
|
|
25254
|
+
const reducedValue = visit(value);
|
|
24008
25255
|
!isUndefined(reducedValue) && (target[key] = reducedValue);
|
|
24009
25256
|
});
|
|
24010
|
-
|
|
25257
|
+
visited.delete(source);
|
|
24011
25258
|
return target;
|
|
24012
25259
|
}
|
|
24013
25260
|
}
|
|
24014
25261
|
return source;
|
|
24015
25262
|
};
|
|
24016
|
-
return visit(obj
|
|
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/
|
|
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
|
-
|
|
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.
|
|
24250
|
-
let obj =
|
|
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 ?
|
|
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 =
|
|
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
|
-
|
|
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
|
|
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
|
-
|
|
24888
|
-
|
|
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
|
|
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
|
-
|
|
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
|
|
25201
|
-
var
|
|
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.
|
|
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 = /^(
|
|
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
|
|
25230
|
-
const
|
|
25231
|
-
const
|
|
25232
|
-
const
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
25982
|
-
|
|
25983
|
-
if (
|
|
25984
|
-
|
|
25985
|
-
|
|
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 } =
|
|
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.
|
|
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
|
|
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
|
-
|
|
26118
|
-
|
|
26119
|
-
|
|
26120
|
-
|
|
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(
|
|
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 (
|
|
26169
|
-
const dataUrl = String(
|
|
27634
|
+
if (maxContentLength > -1) {
|
|
27635
|
+
const dataUrl = String(own2("url") || fullPath || "");
|
|
26170
27636
|
const estimated = estimateDataURLDecodedBytes(dataUrl);
|
|
26171
|
-
if (estimated >
|
|
27637
|
+
if (estimated > maxContentLength) {
|
|
26172
27638
|
return reject(
|
|
26173
27639
|
new AxiosError_default(
|
|
26174
|
-
"maxContentLength size of " +
|
|
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(
|
|
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
|
|
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 (
|
|
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
|
|
26310
|
-
const password = configAuth
|
|
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
|
-
|
|
26324
|
-
|
|
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 =
|
|
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
|
-
|
|
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
|
|
26342
|
-
agents: { http:
|
|
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
|
-
|
|
26352
|
-
|
|
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
|
-
|
|
26358
|
-
|
|
26359
|
-
const
|
|
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 "${
|
|
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 =
|
|
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
|
-
|
|
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
|
|
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 (
|
|
27866
|
+
} else if (maxRedirects === 0) {
|
|
26394
27867
|
transport = isHttpsRequest ? import_https.default : import_http.default;
|
|
26395
27868
|
isNativeTransport = true;
|
|
26396
27869
|
} else {
|
|
26397
|
-
|
|
26398
|
-
|
|
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 (
|
|
26408
|
-
options.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 (
|
|
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 (
|
|
26471
|
-
const limit =
|
|
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 (
|
|
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 " +
|
|
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 (
|
|
26589
|
-
const timeout = parseInt(
|
|
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 (
|
|
26629
|
-
const limit =
|
|
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
|
-
|
|
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
|
-
|
|
26853
|
-
|
|
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(
|
|
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
|
|
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
|
-
|
|
27032
|
-
if (timeout
|
|
27033
|
-
|
|
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
|
|
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
|
|
27286
|
-
if (typeof outboundLength === "number" && isFinite(outboundLength)
|
|
27287
|
-
|
|
27288
|
-
|
|
27289
|
-
|
|
27290
|
-
|
|
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
|
-
|
|
27296
|
-
|
|
27297
|
-
|
|
27298
|
-
|
|
27299
|
-
|
|
27300
|
-
|
|
27301
|
-
|
|
27302
|
-
|
|
27303
|
-
|
|
27304
|
-
}
|
|
27305
|
-
|
|
27306
|
-
|
|
27307
|
-
|
|
27308
|
-
|
|
27309
|
-
|
|
27310
|
-
|
|
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()
|
|
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(
|
|
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(
|
|
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
|
|
29469
|
+
data: config && utils_default.hasOwnProp(config, "data") ? config.data : void 0
|
|
27818
29470
|
})
|
|
27819
29471
|
);
|
|
27820
29472
|
};
|