1739 lines
60 KiB
JavaScript
1739 lines
60 KiB
JavaScript
function f() {
|
|
var define, module, exports;
|
|
return (function() {
|
|
function r(e, n, t) {
|
|
function o(i, f) {
|
|
if (!n[i]) {
|
|
if (!e[i]) {
|
|
var c = "function" == typeof require && require;
|
|
if (!f && c) return c(i, !0);
|
|
if (u) return u(i, !0);
|
|
var a = new Error("Cannot find module '" + i + "'");
|
|
throw a.code = "MODULE_NOT_FOUND", a
|
|
}
|
|
var p = n[i] = {
|
|
exports: {}
|
|
};
|
|
e[i][0].call(p.exports, function(r) {
|
|
var n = e[i][1][r];
|
|
return o(n || r)
|
|
}, p, p.exports, r, e, n, t)
|
|
}
|
|
return n[i].exports
|
|
}
|
|
for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
|
|
return o
|
|
}
|
|
return r
|
|
})()({
|
|
1: [function(require, module, exports) {
|
|
"use strict";
|
|
var replace = String.prototype.replace,
|
|
percentTwenties = /%20/g,
|
|
Format = {
|
|
RFC1738: "RFC1738",
|
|
RFC3986: "RFC3986"
|
|
};
|
|
module.exports = {
|
|
default: Format.RFC3986,
|
|
formatters: {
|
|
RFC1738: function(e) {
|
|
return replace.call(e, percentTwenties, "+")
|
|
},
|
|
RFC3986: function(e) {
|
|
return String(e)
|
|
}
|
|
},
|
|
RFC1738: Format.RFC1738,
|
|
RFC3986: Format.RFC3986
|
|
};
|
|
|
|
}, {}],
|
|
2: [function(require, module, exports) {
|
|
"use strict";
|
|
var stringify = require(4),
|
|
parse = require(3),
|
|
formats = require(1);
|
|
module.exports = {
|
|
formats: formats,
|
|
parse: parse,
|
|
stringify: stringify
|
|
};
|
|
|
|
}, {
|
|
"1": 1,
|
|
"3": 3,
|
|
"4": 4
|
|
}],
|
|
3: [function(require, module, exports) {
|
|
"use strict";
|
|
var utils = require(5),
|
|
has = Object.prototype.hasOwnProperty,
|
|
isArray = Array.isArray,
|
|
defaults = {
|
|
allowDots: !1,
|
|
allowEmptyArrays: !1,
|
|
allowPrototypes: !1,
|
|
allowSparse: !1,
|
|
arrayLimit: 20,
|
|
charset: "utf-8",
|
|
charsetSentinel: !1,
|
|
comma: !1,
|
|
decodeDotInKeys: !1,
|
|
decoder: utils.decode,
|
|
delimiter: "&",
|
|
depth: 5,
|
|
duplicates: "combine",
|
|
ignoreQueryPrefix: !1,
|
|
interpretNumericEntities: !1,
|
|
parameterLimit: 1e3,
|
|
parseArrays: !0,
|
|
plainObjects: !1,
|
|
strictNullHandling: !1
|
|
},
|
|
interpretNumericEntities = function(e) {
|
|
return e.replace(/&#(\d+);/g, (function(e, t) {
|
|
return String.fromCharCode(parseInt(t, 10))
|
|
}))
|
|
},
|
|
parseArrayValue = function(e, t) {
|
|
return e && "string" == typeof e && t.comma && e.indexOf(",") > -1 ? e.split(
|
|
",") : e
|
|
},
|
|
isoSentinel = "utf8=%26%2310003%3B",
|
|
charsetSentinel = "utf8=%E2%9C%93",
|
|
parseValues = function parseQueryStringValues(e, t) {
|
|
var r, a = {
|
|
__proto__: null
|
|
},
|
|
o = t.ignoreQueryPrefix ? e.replace(/^\?/, "") : e,
|
|
i = t.parameterLimit === 1 / 0 ? void 0 : t.parameterLimit,
|
|
l = o.split(t.delimiter, i),
|
|
s = -1,
|
|
n = t.charset;
|
|
if (t.charsetSentinel)
|
|
for (r = 0; r < l.length; ++r) 0 === l[r].indexOf("utf8=") && (l[r] ===
|
|
charsetSentinel ? n = "utf-8" : l[r] === isoSentinel && (n =
|
|
"iso-8859-1"), s = r, r = l.length);
|
|
for (r = 0; r < l.length; ++r)
|
|
if (r !== s) {
|
|
var p, c, d = l[r],
|
|
u = d.indexOf("]="),
|
|
y = -1 === u ? d.indexOf("=") : u + 1; - 1 === y ? (p = t.decoder(d,
|
|
defaults.decoder, n, "key"), c = t.strictNullHandling ?
|
|
null : "") : (p = t.decoder(d.slice(0, y), defaults.decoder, n,
|
|
"key"), c = utils.maybeMap(parseArrayValue(d.slice(y + 1),
|
|
t), (function(e) {
|
|
return t.decoder(e, defaults.decoder, n, "value")
|
|
}))), c && t.interpretNumericEntities && "iso-8859-1" === n && (c =
|
|
interpretNumericEntities(c)), d.indexOf("[]=") > -1 && (c =
|
|
isArray(c) ? [c] : c);
|
|
var f = has.call(a, p);
|
|
f && "combine" === t.duplicates ? a[p] = utils.combine(a[p], c) : f &&
|
|
"last" !== t.duplicates || (a[p] = c)
|
|
} return a
|
|
},
|
|
parseObject = function(e, t, r, a) {
|
|
for (var o = a ? t : parseArrayValue(t, r), i = e.length - 1; i >= 0; --i) {
|
|
var l, s = e[i];
|
|
if ("[]" === s && r.parseArrays) l = r.allowEmptyArrays && "" === o ? [] :
|
|
[].concat(o);
|
|
else {
|
|
l = r.plainObjects ? Object.create(null) : {};
|
|
var n = "[" === s.charAt(0) && "]" === s.charAt(s.length - 1) ? s.slice(
|
|
1, -1) : s,
|
|
p = r.decodeDotInKeys ? n.replace(/%2E/g, ".") : n,
|
|
c = parseInt(p, 10);
|
|
r.parseArrays || "" !== p ? !isNaN(c) && s !== p && String(c) === p &&
|
|
c >= 0 && r.parseArrays && c <= r.arrayLimit ? (l = [])[c] = o :
|
|
"__proto__" !== p && (l[p] = o) : l = {
|
|
0: o
|
|
}
|
|
}
|
|
o = l
|
|
}
|
|
return o
|
|
},
|
|
parseKeys = function parseQueryStringKeys(e, t, r, a) {
|
|
if (e) {
|
|
var o = r.allowDots ? e.replace(/\.([^.[]+)/g, "[$1]") : e,
|
|
i = /(\[[^[\]]*])/g,
|
|
l = r.depth > 0 && /(\[[^[\]]*])/.exec(o),
|
|
s = l ? o.slice(0, l.index) : o,
|
|
n = [];
|
|
if (s) {
|
|
if (!r.plainObjects && has.call(Object.prototype, s) && !r
|
|
.allowPrototypes) return;
|
|
n.push(s)
|
|
}
|
|
for (var p = 0; r.depth > 0 && null !== (l = i.exec(o)) && p < r.depth;) {
|
|
if (p += 1, !r.plainObjects && has.call(Object.prototype, l[1].slice(1,
|
|
-1)) && !r.allowPrototypes) return;
|
|
n.push(l[1])
|
|
}
|
|
return l && n.push("[" + o.slice(l.index) + "]"), parseObject(n, t, r, a)
|
|
}
|
|
},
|
|
normalizeParseOptions = function normalizeParseOptions(e) {
|
|
if (!e) return defaults;
|
|
if (void 0 !== e.allowEmptyArrays && "boolean" != typeof e.allowEmptyArrays)
|
|
throw new TypeError(
|
|
"`allowEmptyArrays` option can only be `true` or `false`, when provided"
|
|
);
|
|
if (void 0 !== e.decodeDotInKeys && "boolean" != typeof e.decodeDotInKeys)
|
|
throw new TypeError(
|
|
"`decodeDotInKeys` option can only be `true` or `false`, when provided"
|
|
);
|
|
if (null !== e.decoder && void 0 !== e.decoder && "function" != typeof e
|
|
.decoder) throw new TypeError("Decoder has to be a function.");
|
|
if (void 0 !== e.charset && "utf-8" !== e.charset && "iso-8859-1" !== e.charset)
|
|
throw new TypeError(
|
|
"The charset option must be either utf-8, iso-8859-1, or undefined");
|
|
var t = void 0 === e.charset ? defaults.charset : e.charset,
|
|
r = void 0 === e.duplicates ? defaults.duplicates : e.duplicates;
|
|
if ("combine" !== r && "first" !== r && "last" !== r) throw new TypeError(
|
|
"The duplicates option must be either combine, first, or last");
|
|
return {
|
|
allowDots: void 0 === e.allowDots ? !0 === e.decodeDotInKeys || defaults
|
|
.allowDots : !!e.allowDots,
|
|
allowEmptyArrays: "boolean" == typeof e.allowEmptyArrays ? !!e
|
|
.allowEmptyArrays : defaults.allowEmptyArrays,
|
|
allowPrototypes: "boolean" == typeof e.allowPrototypes ? e.allowPrototypes :
|
|
defaults.allowPrototypes,
|
|
allowSparse: "boolean" == typeof e.allowSparse ? e.allowSparse : defaults
|
|
.allowSparse,
|
|
arrayLimit: "number" == typeof e.arrayLimit ? e.arrayLimit : defaults
|
|
.arrayLimit,
|
|
charset: t,
|
|
charsetSentinel: "boolean" == typeof e.charsetSentinel ? e.charsetSentinel :
|
|
defaults.charsetSentinel,
|
|
comma: "boolean" == typeof e.comma ? e.comma : defaults.comma,
|
|
decodeDotInKeys: "boolean" == typeof e.decodeDotInKeys ? e.decodeDotInKeys :
|
|
defaults.decodeDotInKeys,
|
|
decoder: "function" == typeof e.decoder ? e.decoder : defaults.decoder,
|
|
delimiter: "string" == typeof e.delimiter || utils.isRegExp(e.delimiter) ? e
|
|
.delimiter : defaults.delimiter,
|
|
depth: "number" == typeof e.depth || !1 === e.depth ? +e.depth : defaults
|
|
.depth,
|
|
duplicates: r,
|
|
ignoreQueryPrefix: !0 === e.ignoreQueryPrefix,
|
|
interpretNumericEntities: "boolean" == typeof e.interpretNumericEntities ? e
|
|
.interpretNumericEntities : defaults.interpretNumericEntities,
|
|
parameterLimit: "number" == typeof e.parameterLimit ? e.parameterLimit :
|
|
defaults.parameterLimit,
|
|
parseArrays: !1 !== e.parseArrays,
|
|
plainObjects: "boolean" == typeof e.plainObjects ? e.plainObjects : defaults
|
|
.plainObjects,
|
|
strictNullHandling: "boolean" == typeof e.strictNullHandling ? e
|
|
.strictNullHandling : defaults.strictNullHandling
|
|
}
|
|
};
|
|
module.exports = function(e, t) {
|
|
var r = normalizeParseOptions(t);
|
|
if ("" === e || null == e) return r.plainObjects ? Object.create(null) : {};
|
|
for (var a = "string" == typeof e ? parseValues(e, r) : e, o = r.plainObjects ?
|
|
Object.create(null) : {}, i = Object.keys(a), l = 0; l < i.length; ++
|
|
l) {
|
|
var s = i[l],
|
|
n = parseKeys(s, a[s], r, "string" == typeof e);
|
|
o = utils.merge(o, n, r)
|
|
}
|
|
return !0 === r.allowSparse ? o : utils.compact(o)
|
|
};
|
|
|
|
}, {
|
|
"5": 5
|
|
}],
|
|
4: [function(require, module, exports) {
|
|
"use strict";
|
|
var getSideChannel = require(29),
|
|
utils = require(5),
|
|
formats = require(1),
|
|
has = Object.prototype.hasOwnProperty,
|
|
arrayPrefixGenerators = {
|
|
brackets: function brackets(e) {
|
|
return e + "[]"
|
|
},
|
|
comma: "comma",
|
|
indices: function indices(e, r) {
|
|
return e + "[" + r + "]"
|
|
},
|
|
repeat: function repeat(e) {
|
|
return e
|
|
}
|
|
},
|
|
isArray = Array.isArray,
|
|
push = Array.prototype.push,
|
|
pushToArray = function(e, r) {
|
|
push.apply(e, isArray(r) ? r : [r])
|
|
},
|
|
toISO = Date.prototype.toISOString,
|
|
defaultFormat = formats.default,
|
|
defaults = {
|
|
addQueryPrefix: !1,
|
|
allowDots: !1,
|
|
allowEmptyArrays: !1,
|
|
arrayFormat: "indices",
|
|
charset: "utf-8",
|
|
charsetSentinel: !1,
|
|
delimiter: "&",
|
|
encode: !0,
|
|
encodeDotInKeys: !1,
|
|
encoder: utils.encode,
|
|
encodeValuesOnly: !1,
|
|
format: defaultFormat,
|
|
formatter: formats.formatters[defaultFormat],
|
|
indices: !1,
|
|
serializeDate: function serializeDate(e) {
|
|
return toISO.call(e)
|
|
},
|
|
skipNulls: !1,
|
|
strictNullHandling: !1
|
|
},
|
|
isNonNullishPrimitive = function isNonNullishPrimitive(e) {
|
|
return "string" == typeof e || "number" == typeof e || "boolean" == typeof e ||
|
|
"symbol" == typeof e || "bigint" == typeof e
|
|
},
|
|
sentinel = {},
|
|
stringify = function stringify(e, r, t, o, a, n, i, l, s, f, u, d, y, c, p, m, h,
|
|
v) {
|
|
for (var w = e, b = v, g = 0, A = !1; void 0 !== (b = b.get(sentinel)) && !A;) {
|
|
var D = b.get(e);
|
|
if (g += 1, void 0 !== D) {
|
|
if (D === g) throw new RangeError("Cyclic object value");
|
|
A = !0
|
|
}
|
|
void 0 === b.get(sentinel) && (g = 0)
|
|
}
|
|
if ("function" == typeof f ? w = f(r, w) : w instanceof Date ? w = y(w) :
|
|
"comma" === t && isArray(w) && (w = utils.maybeMap(w, (function(e) {
|
|
return e instanceof Date ? y(e) : e
|
|
}))), null === w) {
|
|
if (n) return s && !m ? s(r, defaults.encoder, h, "key", c) : r;
|
|
w = ""
|
|
}
|
|
if (isNonNullishPrimitive(w) || utils.isBuffer(w)) return s ? [p(m ? r : s(r,
|
|
defaults.encoder, h, "key", c)) + "=" + p(s(w, defaults.encoder,
|
|
h, "value", c))] : [p(r) + "=" + p(String(w))];
|
|
var E, N = [];
|
|
if (void 0 === w) return N;
|
|
if ("comma" === t && isArray(w)) m && s && (w = utils.maybeMap(w, s)), E = [{
|
|
value: w.length > 0 ? w.join(",") || null : void 0
|
|
}];
|
|
else if (isArray(f)) E = f;
|
|
else {
|
|
var S = Object.keys(w);
|
|
E = u ? S.sort(u) : S
|
|
}
|
|
var O = l ? r.replace(/\./g, "%2E") : r,
|
|
T = o && isArray(w) && 1 === w.length ? O + "[]" : O;
|
|
if (a && isArray(w) && 0 === w.length) return T + "[]";
|
|
for (var k = 0; k < E.length; ++k) {
|
|
var I = E[k],
|
|
P = "object" == typeof I && void 0 !== I.value ? I.value : w[I];
|
|
if (!i || null !== P) {
|
|
var x = d && l ? I.replace(/\./g, "%2E") : I,
|
|
z = isArray(w) ? "function" == typeof t ? t(T, x) : T : T + (d ?
|
|
"." + x : "[" + x + "]");
|
|
v.set(e, g);
|
|
var K = getSideChannel();
|
|
K.set(sentinel, v), pushToArray(N, stringify(P, z, t, o, a, n, i, l,
|
|
"comma" === t && m && isArray(w) ? null : s, f, u, d, y, c,
|
|
p, m, h, K))
|
|
}
|
|
}
|
|
return N
|
|
},
|
|
normalizeStringifyOptions = function normalizeStringifyOptions(e) {
|
|
if (!e) return defaults;
|
|
if (void 0 !== e.allowEmptyArrays && "boolean" != typeof e.allowEmptyArrays)
|
|
throw new TypeError(
|
|
"`allowEmptyArrays` option can only be `true` or `false`, when provided"
|
|
);
|
|
if (void 0 !== e.encodeDotInKeys && "boolean" != typeof e.encodeDotInKeys)
|
|
throw new TypeError(
|
|
"`encodeDotInKeys` option can only be `true` or `false`, when provided"
|
|
);
|
|
if (null !== e.encoder && void 0 !== e.encoder && "function" != typeof e
|
|
.encoder) throw new TypeError("Encoder has to be a function.");
|
|
var r = e.charset || defaults.charset;
|
|
if (void 0 !== e.charset && "utf-8" !== e.charset && "iso-8859-1" !== e.charset)
|
|
throw new TypeError(
|
|
"The charset option must be either utf-8, iso-8859-1, or undefined");
|
|
var t = formats.default;
|
|
if (void 0 !== e.format) {
|
|
if (!has.call(formats.formatters, e.format)) throw new TypeError(
|
|
"Unknown format option provided.");
|
|
t = e.format
|
|
}
|
|
var o, a = formats.formatters[t],
|
|
n = defaults.filter;
|
|
if (("function" == typeof e.filter || isArray(e.filter)) && (n = e.filter), o =
|
|
e.arrayFormat in arrayPrefixGenerators ? e.arrayFormat : "indices" in e ? e
|
|
.indices ? "indices" : "repeat" : defaults.arrayFormat, "commaRoundTrip" in
|
|
e && "boolean" != typeof e.commaRoundTrip) throw new TypeError(
|
|
"`commaRoundTrip` must be a boolean, or absent");
|
|
var i = void 0 === e.allowDots ? !0 === e.encodeDotInKeys || defaults
|
|
.allowDots : !!e.allowDots;
|
|
return {
|
|
addQueryPrefix: "boolean" == typeof e.addQueryPrefix ? e.addQueryPrefix :
|
|
defaults.addQueryPrefix,
|
|
allowDots: i,
|
|
allowEmptyArrays: "boolean" == typeof e.allowEmptyArrays ? !!e
|
|
.allowEmptyArrays : defaults.allowEmptyArrays,
|
|
arrayFormat: o,
|
|
charset: r,
|
|
charsetSentinel: "boolean" == typeof e.charsetSentinel ? e.charsetSentinel :
|
|
defaults.charsetSentinel,
|
|
commaRoundTrip: e.commaRoundTrip,
|
|
delimiter: void 0 === e.delimiter ? defaults.delimiter : e.delimiter,
|
|
encode: "boolean" == typeof e.encode ? e.encode : defaults.encode,
|
|
encodeDotInKeys: "boolean" == typeof e.encodeDotInKeys ? e.encodeDotInKeys :
|
|
defaults.encodeDotInKeys,
|
|
encoder: "function" == typeof e.encoder ? e.encoder : defaults.encoder,
|
|
encodeValuesOnly: "boolean" == typeof e.encodeValuesOnly ? e
|
|
.encodeValuesOnly : defaults.encodeValuesOnly,
|
|
filter: n,
|
|
format: t,
|
|
formatter: a,
|
|
serializeDate: "function" == typeof e.serializeDate ? e.serializeDate :
|
|
defaults.serializeDate,
|
|
skipNulls: "boolean" == typeof e.skipNulls ? e.skipNulls : defaults
|
|
.skipNulls,
|
|
sort: "function" == typeof e.sort ? e.sort : null,
|
|
strictNullHandling: "boolean" == typeof e.strictNullHandling ? e
|
|
.strictNullHandling : defaults.strictNullHandling
|
|
}
|
|
};
|
|
module.exports = function(e, r) {
|
|
var t, o = e,
|
|
a = normalizeStringifyOptions(r);
|
|
"function" == typeof a.filter ? o = (0, a.filter)("", o) : isArray(a.filter) &&
|
|
(t = a.filter);
|
|
var n = [];
|
|
if ("object" != typeof o || null === o) return "";
|
|
var i = arrayPrefixGenerators[a.arrayFormat],
|
|
l = "comma" === i && a.commaRoundTrip;
|
|
t || (t = Object.keys(o)), a.sort && t.sort(a.sort);
|
|
for (var s = getSideChannel(), f = 0; f < t.length; ++f) {
|
|
var u = t[f];
|
|
a.skipNulls && null === o[u] || pushToArray(n, stringify(o[u], u, i, l, a
|
|
.allowEmptyArrays, a.strictNullHandling, a.skipNulls, a
|
|
.encodeDotInKeys, a.encode ? a.encoder : null, a.filter, a.sort,
|
|
a.allowDots, a.serializeDate, a.format, a.formatter, a
|
|
.encodeValuesOnly, a.charset, s))
|
|
}
|
|
var d = n.join(a.delimiter),
|
|
y = !0 === a.addQueryPrefix ? "?" : "";
|
|
return a.charsetSentinel && ("iso-8859-1" === a.charset ? y +=
|
|
"utf8=%26%2310003%3B&" : y += "utf8=%E2%9C%93&"), d.length > 0 ? y + d :
|
|
""
|
|
};
|
|
|
|
}, {
|
|
"1": 1,
|
|
"29": 29,
|
|
"5": 5
|
|
}],
|
|
5: [function(require, module, exports) {
|
|
"use strict";
|
|
var formats = require(1),
|
|
has = Object.prototype.hasOwnProperty,
|
|
isArray = Array.isArray,
|
|
hexTable = function() {
|
|
for (var e = [], r = 0; r < 256; ++r) e.push("%" + ((r < 16 ? "0" : "") + r
|
|
.toString(16)).toUpperCase());
|
|
return e
|
|
}(),
|
|
compactQueue = function compactQueue(e) {
|
|
for (; e.length > 1;) {
|
|
var r = e.pop(),
|
|
t = r.obj[r.prop];
|
|
if (isArray(t)) {
|
|
for (var o = [], n = 0; n < t.length; ++n) void 0 !== t[n] && o.push(t[
|
|
n]);
|
|
r.obj[r.prop] = o
|
|
}
|
|
}
|
|
},
|
|
arrayToObject = function arrayToObject(e, r) {
|
|
for (var t = r && r.plainObjects ? Object.create(null) : {}, o = 0; o < e
|
|
.length; ++o) void 0 !== e[o] && (t[o] = e[o]);
|
|
return t
|
|
},
|
|
merge = function merge(e, r, t) {
|
|
if (!r) return e;
|
|
if ("object" != typeof r) {
|
|
if (isArray(e)) e.push(r);
|
|
else {
|
|
if (!e || "object" != typeof e) return [e, r];
|
|
(t && (t.plainObjects || t.allowPrototypes) || !has.call(Object
|
|
.prototype, r)) && (e[r] = !0)
|
|
}
|
|
return e
|
|
}
|
|
if (!e || "object" != typeof e) return [e].concat(r);
|
|
var o = e;
|
|
return isArray(e) && !isArray(r) && (o = arrayToObject(e, t)), isArray(e) &&
|
|
isArray(r) ? (r.forEach((function(r, o) {
|
|
if (has.call(e, o)) {
|
|
var n = e[o];
|
|
n && "object" == typeof n && r && "object" == typeof r ?
|
|
e[o] = merge(n, r, t) : e.push(r)
|
|
} else e[o] = r
|
|
})), e) : Object.keys(r).reduce((function(e, o) {
|
|
var n = r[o];
|
|
return has.call(e, o) ? e[o] = merge(e[o], n, t) : e[o] = n, e
|
|
}), o)
|
|
},
|
|
assign = function assignSingleSource(e, r) {
|
|
return Object.keys(r).reduce((function(e, t) {
|
|
return e[t] = r[t], e
|
|
}), e)
|
|
},
|
|
decode = function(e, r, t) {
|
|
var o = e.replace(/\+/g, " ");
|
|
if ("iso-8859-1" === t) return o.replace(/%[0-9a-f]{2}/gi, unescape);
|
|
try {
|
|
return decodeURIComponent(o)
|
|
} catch (e) {
|
|
return o
|
|
}
|
|
},
|
|
limit = 1024,
|
|
encode = function encode(e, r, t, o, n) {
|
|
if (0 === e.length) return e;
|
|
var a = e;
|
|
if ("symbol" == typeof e ? a = Symbol.prototype.toString.call(e) : "string" !=
|
|
typeof e && (a = String(e)), "iso-8859-1" === t) return escape(a).replace(
|
|
/%u[0-9a-f]{4}/gi, (function(e) {
|
|
return "%26%23" + parseInt(e.slice(2), 16) + "%3B"
|
|
}));
|
|
for (var c = "", i = 0; i < a.length; i += limit) {
|
|
for (var u = a.length >= limit ? a.slice(i, i + limit) : a, p = [], s =
|
|
0; s < u.length; ++s) {
|
|
var f = u.charCodeAt(s);
|
|
45 === f || 46 === f || 95 === f || 126 === f || f >= 48 && f <= 57 ||
|
|
f >= 65 && f <= 90 || f >= 97 && f <= 122 || n === formats
|
|
.RFC1738 && (40 === f || 41 === f) ? p[p.length] = u.charAt(s) : f <
|
|
128 ? p[p.length] = hexTable[f] : f < 2048 ? p[p.length] = hexTable[
|
|
192 | f >> 6] + hexTable[128 | 63 & f] : f < 55296 || f >=
|
|
57344 ? p[p.length] = hexTable[224 | f >> 12] + hexTable[128 | f >>
|
|
6 & 63] + hexTable[128 | 63 & f] : (s += 1, f = 65536 + ((1023 &
|
|
f) << 10 | 1023 & u.charCodeAt(s)), p[p.length] = hexTable[
|
|
240 | f >> 18] + hexTable[128 | f >> 12 & 63] + hexTable[
|
|
128 | f >> 6 & 63] + hexTable[128 | 63 & f])
|
|
}
|
|
c += p.join("")
|
|
}
|
|
return c
|
|
},
|
|
compact = function compact(e) {
|
|
for (var r = [{
|
|
obj: {
|
|
o: e
|
|
},
|
|
prop: "o"
|
|
}], t = [], o = 0; o < r.length; ++o)
|
|
for (var n = r[o], a = n.obj[n.prop], c = Object.keys(a), i = 0; i < c
|
|
.length; ++i) {
|
|
var u = c[i],
|
|
p = a[u];
|
|
"object" == typeof p && null !== p && -1 === t.indexOf(p) && (r.push({
|
|
obj: a,
|
|
prop: u
|
|
}), t.push(p))
|
|
}
|
|
return compactQueue(r), e
|
|
},
|
|
isRegExp = function isRegExp(e) {
|
|
return "[object RegExp]" === Object.prototype.toString.call(e)
|
|
},
|
|
isBuffer = function isBuffer(e) {
|
|
return !(!e || "object" != typeof e || !(e.constructor && e.constructor
|
|
.isBuffer && e.constructor.isBuffer(e)))
|
|
},
|
|
combine = function combine(e, r) {
|
|
return [].concat(e, r)
|
|
},
|
|
maybeMap = function maybeMap(e, r) {
|
|
if (isArray(e)) {
|
|
for (var t = [], o = 0; o < e.length; o += 1) t.push(r(e[o]));
|
|
return t
|
|
}
|
|
return r(e)
|
|
};
|
|
module.exports = {
|
|
/* common-shake removed: arrayToObject:arrayToObject */ /* common-shake removed: assign:assign */
|
|
combine: combine,
|
|
compact: compact,
|
|
decode: decode,
|
|
encode: encode,
|
|
isBuffer: isBuffer,
|
|
isRegExp: isRegExp,
|
|
maybeMap: maybeMap,
|
|
merge: merge
|
|
};
|
|
|
|
}, {
|
|
"1": 1
|
|
}],
|
|
29: [function(require, module, exports) {
|
|
"use strict";
|
|
var GetIntrinsic = require(20),
|
|
callBound = require(7),
|
|
inspect = require(27),
|
|
$TypeError = require(16),
|
|
$WeakMap = GetIntrinsic("%WeakMap%", !0),
|
|
$Map = GetIntrinsic("%Map%", !0),
|
|
$weakMapGet = callBound("WeakMap.prototype.get", !0),
|
|
$weakMapSet = callBound("WeakMap.prototype.set", !0),
|
|
$weakMapHas = callBound("WeakMap.prototype.has", !0),
|
|
$mapGet = callBound("Map.prototype.get", !0),
|
|
$mapSet = callBound("Map.prototype.set", !0),
|
|
$mapHas = callBound("Map.prototype.has", !0),
|
|
listGetNode = function(e, t) {
|
|
for (var n, a = e; null !== (n = a.next); a = n)
|
|
if (n.key === t) return a.next = n.next, n.next = e.next, e.next = n, n
|
|
},
|
|
listGet = function(e, t) {
|
|
var n = listGetNode(e, t);
|
|
return n && n.value
|
|
},
|
|
listSet = function(e, t, n) {
|
|
var a = listGetNode(e, t);
|
|
a ? a.value = n : e.next = {
|
|
key: t,
|
|
next: e.next,
|
|
value: n
|
|
}
|
|
},
|
|
listHas = function(e, t) {
|
|
return !!listGetNode(e, t)
|
|
};
|
|
module.exports = function getSideChannel() {
|
|
var e, t, n, a = {
|
|
assert: function(e) {
|
|
if (!a.has(e)) throw new $TypeError(
|
|
"Side channel does not contain " + inspect(e))
|
|
},
|
|
get: function(a) {
|
|
if ($WeakMap && a && ("object" == typeof a || "function" ==
|
|
typeof a)) {
|
|
if (e) return $weakMapGet(e, a)
|
|
} else if ($Map) {
|
|
if (t) return $mapGet(t, a)
|
|
} else if (n) return listGet(n, a)
|
|
},
|
|
has: function(a) {
|
|
if ($WeakMap && a && ("object" == typeof a || "function" ==
|
|
typeof a)) {
|
|
if (e) return $weakMapHas(e, a)
|
|
} else if ($Map) {
|
|
if (t) return $mapHas(t, a)
|
|
} else if (n) return listHas(n, a);
|
|
return !1
|
|
},
|
|
set: function(a, r) {
|
|
$WeakMap && a && ("object" == typeof a || "function" ==
|
|
typeof a) ? (e || (e = new $WeakMap), $weakMapSet(e, a,
|
|
r)) : $Map ? (t || (t = new $Map), $mapSet(t, a, r)) : (
|
|
n || (n = {
|
|
key: {},
|
|
next: null
|
|
}), listSet(n, a, r))
|
|
}
|
|
};
|
|
return a
|
|
};
|
|
|
|
}, {
|
|
"16": 16,
|
|
"20": 20,
|
|
"27": 27,
|
|
"7": 7
|
|
}],
|
|
6: [function(require, module, exports) {
|
|
|
|
}, {}],
|
|
7: [function(require, module, exports) {
|
|
"use strict";
|
|
var GetIntrinsic = require(20),
|
|
callBind = require(8),
|
|
$indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
|
|
module.exports = function callBoundIntrinsic(i, n) {
|
|
var t = GetIntrinsic(i, !!n);
|
|
return "function" == typeof t && $indexOf(i, ".prototype.") > -1 ? callBind(t) :
|
|
t
|
|
};
|
|
|
|
}, {
|
|
"20": 20,
|
|
"8": 8
|
|
}],
|
|
20: [function(require, module, exports) {
|
|
"use strict";
|
|
var undefined, $Error = require(12),
|
|
$EvalError = require(11),
|
|
$RangeError = require(13),
|
|
$ReferenceError = require(14),
|
|
$SyntaxError = require(15),
|
|
$TypeError = require(16),
|
|
$URIError = require(17),
|
|
$Function = Function,
|
|
getEvalledConstructor = function(r) {
|
|
try {
|
|
return $Function('"use strict"; return (' + r + ").constructor;")()
|
|
} catch (r) {}
|
|
},
|
|
$gOPD = Object.getOwnPropertyDescriptor;
|
|
if ($gOPD) try {
|
|
$gOPD({}, "")
|
|
} catch (r) {
|
|
$gOPD = null
|
|
}
|
|
var throwTypeError = function() {
|
|
throw new $TypeError
|
|
},
|
|
ThrowTypeError = $gOPD ? function() {
|
|
try {
|
|
return throwTypeError
|
|
} catch (r) {
|
|
try {
|
|
return $gOPD(arguments, "callee").get
|
|
} catch (r) {
|
|
return throwTypeError
|
|
}
|
|
}
|
|
}() : throwTypeError,
|
|
hasSymbols = require(24)(),
|
|
hasProto = require(23)(),
|
|
getProto = Object.getPrototypeOf || (hasProto ? function(r) {
|
|
return r.__proto__
|
|
} : null),
|
|
needsEval = {},
|
|
TypedArray = "undefined" != typeof Uint8Array && getProto ? getProto(Uint8Array) :
|
|
undefined,
|
|
INTRINSICS = {
|
|
__proto__: null,
|
|
"%AggregateError%": "undefined" == typeof AggregateError ? undefined :
|
|
AggregateError,
|
|
"%Array%": Array,
|
|
"%ArrayBuffer%": "undefined" == typeof ArrayBuffer ? undefined : ArrayBuffer,
|
|
"%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol
|
|
.iterator]()) : undefined,
|
|
"%AsyncFromSyncIteratorPrototype%": undefined,
|
|
"%AsyncFunction%": needsEval,
|
|
"%AsyncGenerator%": needsEval,
|
|
"%AsyncGeneratorFunction%": needsEval,
|
|
"%AsyncIteratorPrototype%": needsEval,
|
|
"%Atomics%": "undefined" == typeof Atomics ? undefined : Atomics,
|
|
"%BigInt%": "undefined" == typeof BigInt ? undefined : BigInt,
|
|
"%BigInt64Array%": "undefined" == typeof BigInt64Array ? undefined :
|
|
BigInt64Array,
|
|
"%BigUint64Array%": "undefined" == typeof BigUint64Array ? undefined :
|
|
BigUint64Array,
|
|
"%Boolean%": Boolean,
|
|
"%DataView%": "undefined" == typeof DataView ? undefined : DataView,
|
|
"%Date%": Date,
|
|
"%decodeURI%": decodeURI,
|
|
"%decodeURIComponent%": decodeURIComponent,
|
|
"%encodeURI%": encodeURI,
|
|
"%encodeURIComponent%": encodeURIComponent,
|
|
"%Error%": $Error,
|
|
"%eval%": eval,
|
|
"%EvalError%": $EvalError,
|
|
"%Float32Array%": "undefined" == typeof Float32Array ? undefined : Float32Array,
|
|
"%Float64Array%": "undefined" == typeof Float64Array ? undefined : Float64Array,
|
|
"%FinalizationRegistry%": "undefined" == typeof FinalizationRegistry ?
|
|
undefined : FinalizationRegistry,
|
|
"%Function%": $Function,
|
|
"%GeneratorFunction%": needsEval,
|
|
"%Int8Array%": "undefined" == typeof Int8Array ? undefined : Int8Array,
|
|
"%Int16Array%": "undefined" == typeof Int16Array ? undefined : Int16Array,
|
|
"%Int32Array%": "undefined" == typeof Int32Array ? undefined : Int32Array,
|
|
"%isFinite%": isFinite,
|
|
"%isNaN%": isNaN,
|
|
"%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol
|
|
.iterator
|
|
]())) : undefined,
|
|
"%JSON%": "object" == typeof JSON ? JSON : undefined,
|
|
"%Map%": "undefined" == typeof Map ? undefined : Map,
|
|
"%MapIteratorPrototype%": "undefined" != typeof Map && hasSymbols && getProto ?
|
|
getProto((new Map)[Symbol.iterator]()) : undefined,
|
|
"%Math%": Math,
|
|
"%Number%": Number,
|
|
"%Object%": Object,
|
|
"%parseFloat%": parseFloat,
|
|
"%parseInt%": parseInt,
|
|
"%Promise%": "undefined" == typeof Promise ? undefined : Promise,
|
|
"%Proxy%": "undefined" == typeof Proxy ? undefined : Proxy,
|
|
"%RangeError%": $RangeError,
|
|
"%ReferenceError%": $ReferenceError,
|
|
"%Reflect%": "undefined" == typeof Reflect ? undefined : Reflect,
|
|
"%RegExp%": RegExp,
|
|
"%Set%": "undefined" == typeof Set ? undefined : Set,
|
|
"%SetIteratorPrototype%": "undefined" != typeof Set && hasSymbols && getProto ?
|
|
getProto((new Set)[Symbol.iterator]()) : undefined,
|
|
"%SharedArrayBuffer%": "undefined" == typeof SharedArrayBuffer ? undefined :
|
|
SharedArrayBuffer,
|
|
"%String%": String,
|
|
"%StringIteratorPrototype%": hasSymbols && getProto ? getProto("" [Symbol
|
|
.iterator
|
|
]()) : undefined,
|
|
"%Symbol%": hasSymbols ? Symbol : undefined,
|
|
"%SyntaxError%": $SyntaxError,
|
|
"%ThrowTypeError%": ThrowTypeError,
|
|
"%TypedArray%": TypedArray,
|
|
"%TypeError%": $TypeError,
|
|
"%Uint8Array%": "undefined" == typeof Uint8Array ? undefined : Uint8Array,
|
|
"%Uint8ClampedArray%": "undefined" == typeof Uint8ClampedArray ? undefined :
|
|
Uint8ClampedArray,
|
|
"%Uint16Array%": "undefined" == typeof Uint16Array ? undefined : Uint16Array,
|
|
"%Uint32Array%": "undefined" == typeof Uint32Array ? undefined : Uint32Array,
|
|
"%URIError%": $URIError,
|
|
"%WeakMap%": "undefined" == typeof WeakMap ? undefined : WeakMap,
|
|
"%WeakRef%": "undefined" == typeof WeakRef ? undefined : WeakRef,
|
|
"%WeakSet%": "undefined" == typeof WeakSet ? undefined : WeakSet
|
|
};
|
|
if (getProto) try {
|
|
null.error
|
|
} catch (r) {
|
|
var errorProto = getProto(getProto(r));
|
|
INTRINSICS["%Error.prototype%"] = errorProto
|
|
}
|
|
var doEval = function doEval(r) {
|
|
var e;
|
|
if ("%AsyncFunction%" === r) e = getEvalledConstructor("async function () {}");
|
|
else if ("%GeneratorFunction%" === r) e = getEvalledConstructor(
|
|
"function* () {}");
|
|
else if ("%AsyncGeneratorFunction%" === r) e = getEvalledConstructor(
|
|
"async function* () {}");
|
|
else if ("%AsyncGenerator%" === r) {
|
|
var t = doEval("%AsyncGeneratorFunction%");
|
|
t && (e = t.prototype)
|
|
} else if ("%AsyncIteratorPrototype%" === r) {
|
|
var o = doEval("%AsyncGenerator%");
|
|
o && getProto && (e = getProto(o.prototype))
|
|
}
|
|
return INTRINSICS[r] = e, e
|
|
},
|
|
LEGACY_ALIASES = {
|
|
__proto__: null,
|
|
"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
|
|
"%ArrayPrototype%": ["Array", "prototype"],
|
|
"%ArrayProto_entries%": ["Array", "prototype", "entries"],
|
|
"%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
|
|
"%ArrayProto_keys%": ["Array", "prototype", "keys"],
|
|
"%ArrayProto_values%": ["Array", "prototype", "values"],
|
|
"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
|
|
"%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
|
|
"%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype",
|
|
"prototype"],
|
|
"%BooleanPrototype%": ["Boolean", "prototype"],
|
|
"%DataViewPrototype%": ["DataView", "prototype"],
|
|
"%DatePrototype%": ["Date", "prototype"],
|
|
"%ErrorPrototype%": ["Error", "prototype"],
|
|
"%EvalErrorPrototype%": ["EvalError", "prototype"],
|
|
"%Float32ArrayPrototype%": ["Float32Array", "prototype"],
|
|
"%Float64ArrayPrototype%": ["Float64Array", "prototype"],
|
|
"%FunctionPrototype%": ["Function", "prototype"],
|
|
"%Generator%": ["GeneratorFunction", "prototype"],
|
|
"%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
|
|
"%Int8ArrayPrototype%": ["Int8Array", "prototype"],
|
|
"%Int16ArrayPrototype%": ["Int16Array", "prototype"],
|
|
"%Int32ArrayPrototype%": ["Int32Array", "prototype"],
|
|
"%JSONParse%": ["JSON", "parse"],
|
|
"%JSONStringify%": ["JSON", "stringify"],
|
|
"%MapPrototype%": ["Map", "prototype"],
|
|
"%NumberPrototype%": ["Number", "prototype"],
|
|
"%ObjectPrototype%": ["Object", "prototype"],
|
|
"%ObjProto_toString%": ["Object", "prototype", "toString"],
|
|
"%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
|
|
"%PromisePrototype%": ["Promise", "prototype"],
|
|
"%PromiseProto_then%": ["Promise", "prototype", "then"],
|
|
"%Promise_all%": ["Promise", "all"],
|
|
"%Promise_reject%": ["Promise", "reject"],
|
|
"%Promise_resolve%": ["Promise", "resolve"],
|
|
"%RangeErrorPrototype%": ["RangeError", "prototype"],
|
|
"%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
|
|
"%RegExpPrototype%": ["RegExp", "prototype"],
|
|
"%SetPrototype%": ["Set", "prototype"],
|
|
"%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
|
|
"%StringPrototype%": ["String", "prototype"],
|
|
"%SymbolPrototype%": ["Symbol", "prototype"],
|
|
"%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
|
|
"%TypedArrayPrototype%": ["TypedArray", "prototype"],
|
|
"%TypeErrorPrototype%": ["TypeError", "prototype"],
|
|
"%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
|
|
"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
|
|
"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
|
|
"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
|
|
"%URIErrorPrototype%": ["URIError", "prototype"],
|
|
"%WeakMapPrototype%": ["WeakMap", "prototype"],
|
|
"%WeakSetPrototype%": ["WeakSet", "prototype"]
|
|
},
|
|
bind = require(19),
|
|
hasOwn = require(26),
|
|
$concat = bind.call(Function.call, Array.prototype.concat),
|
|
$spliceApply = bind.call(Function.apply, Array.prototype.splice),
|
|
$replace = bind.call(Function.call, String.prototype.replace),
|
|
$strSlice = bind.call(Function.call, String.prototype.slice),
|
|
$exec = bind.call(Function.call, RegExp.prototype.exec),
|
|
rePropName =
|
|
/[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,
|
|
reEscapeChar = /\\(\\)?/g,
|
|
stringToPath = function stringToPath(r) {
|
|
var e = $strSlice(r, 0, 1),
|
|
t = $strSlice(r, -1);
|
|
if ("%" === e && "%" !== t) throw new $SyntaxError(
|
|
"invalid intrinsic syntax, expected closing `%`");
|
|
if ("%" === t && "%" !== e) throw new $SyntaxError(
|
|
"invalid intrinsic syntax, expected opening `%`");
|
|
var o = [];
|
|
return $replace(r, rePropName, (function(r, e, t, n) {
|
|
o[o.length] = t ? $replace(n, reEscapeChar, "$1") : e || r
|
|
})), o
|
|
},
|
|
getBaseIntrinsic = function getBaseIntrinsic(r, e) {
|
|
var t, o = r;
|
|
if (hasOwn(LEGACY_ALIASES, o) && (o = "%" + (t = LEGACY_ALIASES[o])[0] + "%"),
|
|
hasOwn(INTRINSICS, o)) {
|
|
var n = INTRINSICS[o];
|
|
if (n === needsEval && (n = doEval(o)), void 0 === n && !e)
|
|
throw new $TypeError("intrinsic " + r +
|
|
" exists, but is not available. Please file an issue!");
|
|
return {
|
|
alias: t,
|
|
name: o,
|
|
value: n
|
|
}
|
|
}
|
|
throw new $SyntaxError("intrinsic " + r + " does not exist!")
|
|
};
|
|
module.exports = function GetIntrinsic(r, e) {
|
|
if ("string" != typeof r || 0 === r.length) throw new $TypeError(
|
|
"intrinsic name must be a non-empty string");
|
|
if (arguments.length > 1 && "boolean" != typeof e) throw new $TypeError(
|
|
'"allowMissing" argument must be a boolean');
|
|
if (null === $exec(/^%?[^%]*%?$/, r)) throw new $SyntaxError(
|
|
"`%` may not be present anywhere but at the beginning and end of the intrinsic name"
|
|
);
|
|
var t = stringToPath(r),
|
|
o = t.length > 0 ? t[0] : "",
|
|
n = getBaseIntrinsic("%" + o + "%", e),
|
|
a = n.name,
|
|
y = n.value,
|
|
i = !1,
|
|
p = n.alias;
|
|
p && (o = p[0], $spliceApply(t, $concat([0, 1], p)));
|
|
for (var d = 1, s = !0; d < t.length; d += 1) {
|
|
var f = t[d],
|
|
u = $strSlice(f, 0, 1),
|
|
l = $strSlice(f, -1);
|
|
if (('"' === u || "'" === u || "`" === u || '"' === l || "'" === l ||
|
|
"`" === l) && u !== l) throw new $SyntaxError(
|
|
"property names with quotes must have matching quotes");
|
|
if ("constructor" !== f && s || (i = !0), hasOwn(INTRINSICS, a = "%" + (o +=
|
|
"." + f) + "%")) y = INTRINSICS[a];
|
|
else if (null != y) {
|
|
if (!(f in y)) {
|
|
if (!e) throw new $TypeError("base intrinsic for " + r +
|
|
" exists, but the property is not available.");
|
|
return
|
|
}
|
|
if ($gOPD && d + 1 >= t.length) {
|
|
var c = $gOPD(y, f);
|
|
y = (s = !!c) && "get" in c && !("originalValue" in c.get) ? c.get :
|
|
y[f]
|
|
} else s = hasOwn(y, f), y = y[f];
|
|
s && !i && (INTRINSICS[a] = y)
|
|
}
|
|
}
|
|
return y
|
|
};
|
|
|
|
}, {
|
|
"11": 11,
|
|
"12": 12,
|
|
"13": 13,
|
|
"14": 14,
|
|
"15": 15,
|
|
"16": 16,
|
|
"17": 17,
|
|
"19": 19,
|
|
"23": 23,
|
|
"24": 24,
|
|
"26": 26
|
|
}],
|
|
8: [function(require, module, exports) {
|
|
"use strict";
|
|
var bind = require(19),
|
|
GetIntrinsic = require(20),
|
|
setFunctionLength = require(28),
|
|
$TypeError = require(16),
|
|
$apply = GetIntrinsic("%Function.prototype.apply%"),
|
|
$call = GetIntrinsic("%Function.prototype.call%"),
|
|
$reflectApply = GetIntrinsic("%Reflect.apply%", !0) || bind.call($call, $apply),
|
|
$defineProperty = require(10),
|
|
$max = GetIntrinsic("%Math.max%");
|
|
module.exports = function callBind(e) {
|
|
if ("function" != typeof e) throw new $TypeError("a function is required");
|
|
var n = $reflectApply(bind, $call, arguments);
|
|
return setFunctionLength(n, 1 + $max(0, e.length - (arguments.length - 1)), !0)
|
|
};
|
|
var applyBind = function applyBind() {
|
|
return $reflectApply(bind, $apply, arguments)
|
|
};
|
|
$defineProperty ? $defineProperty(module.exports, "apply", {
|
|
value: applyBind
|
|
}) : module.exports.apply = applyBind;
|
|
|
|
}, {
|
|
"10": 10,
|
|
"16": 16,
|
|
"19": 19,
|
|
"20": 20,
|
|
"28": 28
|
|
}],
|
|
16: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = TypeError;
|
|
|
|
}, {}],
|
|
19: [function(require, module, exports) {
|
|
"use strict";
|
|
var implementation = require(18);
|
|
module.exports = Function.prototype.bind || implementation;
|
|
|
|
}, {
|
|
"18": 18
|
|
}],
|
|
10: [function(require, module, exports) {
|
|
"use strict";
|
|
var GetIntrinsic = require(20),
|
|
$defineProperty = GetIntrinsic("%Object.defineProperty%", !0) || !1;
|
|
if ($defineProperty) try {
|
|
$defineProperty({}, "a", {
|
|
value: 1
|
|
})
|
|
} catch (e) {
|
|
$defineProperty = !1
|
|
}
|
|
module.exports = $defineProperty;
|
|
|
|
}, {
|
|
"20": 20
|
|
}],
|
|
28: [function(require, module, exports) {
|
|
"use strict";
|
|
var GetIntrinsic = require(20),
|
|
define = require(9),
|
|
hasDescriptors = require(22)(),
|
|
gOPD = require(21),
|
|
$TypeError = require(16),
|
|
$floor = GetIntrinsic("%Math.floor%");
|
|
module.exports = function setFunctionLength(e, r) {
|
|
if ("function" != typeof e) throw new $TypeError("`fn` is not a function");
|
|
if ("number" != typeof r || r < 0 || r > 4294967295 || $floor(r) !== r)
|
|
throw new $TypeError("`length` must be a positive 32-bit integer");
|
|
var t = arguments.length > 2 && !!arguments[2],
|
|
i = !0,
|
|
n = !0;
|
|
if ("length" in e && gOPD) {
|
|
var o = gOPD(e, "length");
|
|
o && !o.configurable && (i = !1), o && !o.writable && (n = !1)
|
|
}
|
|
return (i || n || !t) && (hasDescriptors ? define(e, "length", r, !0, !0) :
|
|
define(e, "length", r)), e
|
|
};
|
|
|
|
}, {
|
|
"16": 16,
|
|
"20": 20,
|
|
"21": 21,
|
|
"22": 22,
|
|
"9": 9
|
|
}],
|
|
9: [function(require, module, exports) {
|
|
"use strict";
|
|
var $defineProperty = require(10),
|
|
$SyntaxError = require(15),
|
|
$TypeError = require(16),
|
|
gopd = require(21);
|
|
module.exports = function defineDataProperty(e, r, o) {
|
|
if (!e || "object" != typeof e && "function" != typeof e) throw new $TypeError(
|
|
"`obj` must be an object or a function`");
|
|
if ("string" != typeof r && "symbol" != typeof r) throw new $TypeError(
|
|
"`property` must be a string or a symbol`");
|
|
if (arguments.length > 3 && "boolean" != typeof arguments[3] && null !==
|
|
arguments[3]) throw new $TypeError(
|
|
"`nonEnumerable`, if provided, must be a boolean or null");
|
|
if (arguments.length > 4 && "boolean" != typeof arguments[4] && null !==
|
|
arguments[4]) throw new $TypeError(
|
|
"`nonWritable`, if provided, must be a boolean or null");
|
|
if (arguments.length > 5 && "boolean" != typeof arguments[5] && null !==
|
|
arguments[5]) throw new $TypeError(
|
|
"`nonConfigurable`, if provided, must be a boolean or null");
|
|
if (arguments.length > 6 && "boolean" != typeof arguments[6])
|
|
throw new $TypeError("`loose`, if provided, must be a boolean");
|
|
var n = arguments.length > 3 ? arguments[3] : null,
|
|
l = arguments.length > 4 ? arguments[4] : null,
|
|
t = arguments.length > 5 ? arguments[5] : null,
|
|
i = arguments.length > 6 && arguments[6],
|
|
a = !!gopd && gopd(e, r);
|
|
if ($defineProperty) $defineProperty(e, r, {
|
|
configurable: null === t && a ? a.configurable : !t,
|
|
enumerable: null === n && a ? a.enumerable : !n,
|
|
value: o,
|
|
writable: null === l && a ? a.writable : !l
|
|
});
|
|
else {
|
|
if (!i && (n || l || t)) throw new $SyntaxError(
|
|
"This environment does not support defining a property as non-configurable, non-writable, or non-enumerable."
|
|
);
|
|
e[r] = o
|
|
}
|
|
};
|
|
|
|
}, {
|
|
"10": 10,
|
|
"15": 15,
|
|
"16": 16,
|
|
"21": 21
|
|
}],
|
|
15: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = SyntaxError;
|
|
|
|
}, {}],
|
|
21: [function(require, module, exports) {
|
|
"use strict";
|
|
var GetIntrinsic = require(20),
|
|
$gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", !0);
|
|
if ($gOPD) try {
|
|
$gOPD([], "length")
|
|
} catch (t) {
|
|
$gOPD = null
|
|
}
|
|
module.exports = $gOPD;
|
|
|
|
}, {
|
|
"20": 20
|
|
}],
|
|
11: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = EvalError;
|
|
|
|
}, {}],
|
|
12: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = Error;
|
|
|
|
}, {}],
|
|
13: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = RangeError;
|
|
|
|
}, {}],
|
|
14: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = ReferenceError;
|
|
|
|
}, {}],
|
|
17: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = URIError;
|
|
|
|
}, {}],
|
|
18: [function(require, module, exports) {
|
|
"use strict";
|
|
var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ",
|
|
toStr = Object.prototype.toString,
|
|
max = Math.max,
|
|
funcType = "[object Function]",
|
|
concatty = function concatty(t, n) {
|
|
for (var r = [], o = 0; o < t.length; o += 1) r[o] = t[o];
|
|
for (var e = 0; e < n.length; e += 1) r[e + t.length] = n[e];
|
|
return r
|
|
},
|
|
slicy = function slicy(t, n) {
|
|
for (var r = [], o = n || 0, e = 0; o < t.length; o += 1, e += 1) r[e] = t[o];
|
|
return r
|
|
},
|
|
joiny = function(t, n) {
|
|
for (var r = "", o = 0; o < t.length; o += 1) r += t[o], o + 1 < t.length && (
|
|
r += n);
|
|
return r
|
|
};
|
|
module.exports = function bind(t) {
|
|
var n = this;
|
|
if ("function" != typeof n || toStr.apply(n) !== funcType) throw new TypeError(
|
|
ERROR_MESSAGE + n);
|
|
for (var r, o = slicy(arguments, 1), e = max(0, n.length - o.length), i = [],
|
|
c = 0; c < e; c++) i[c] = "$" + c;
|
|
if (r = Function("binder", "return function (" + joiny(i, ",") +
|
|
"){ return binder.apply(this,arguments); }")((function() {
|
|
if (this instanceof r) {
|
|
var e = n.apply(this, concatty(o, arguments));
|
|
return Object(e) === e ? e : this
|
|
}
|
|
return n.apply(t, concatty(o, arguments))
|
|
})), n.prototype) {
|
|
var p = function Empty() {};
|
|
p.prototype = n.prototype, r.prototype = new p, p.prototype = null
|
|
}
|
|
return r
|
|
};
|
|
|
|
}, {}],
|
|
23: [function(require, module, exports) {
|
|
"use strict";
|
|
var test = {
|
|
__proto__: null,
|
|
foo: {}
|
|
},
|
|
$Object = Object;
|
|
module.exports = function hasProto() {
|
|
return {
|
|
__proto__: test
|
|
}.foo === test.foo && !(test instanceof $Object)
|
|
};
|
|
|
|
}, {}],
|
|
26: [function(require, module, exports) {
|
|
"use strict";
|
|
var call = Function.prototype.call,
|
|
$hasOwn = Object.prototype.hasOwnProperty,
|
|
bind = require(19);
|
|
module.exports = bind.call(call, $hasOwn);
|
|
|
|
}, {
|
|
"19": 19
|
|
}],
|
|
24: [function(require, module, exports) {
|
|
"use strict";
|
|
var origSymbol = "undefined" != typeof Symbol && Symbol,
|
|
hasSymbolSham = require(25);
|
|
module.exports = function hasNativeSymbols() {
|
|
return "function" == typeof origSymbol && "function" == typeof Symbol &&
|
|
"symbol" == typeof origSymbol("foo") && "symbol" == typeof Symbol("bar") &&
|
|
hasSymbolSham()
|
|
};
|
|
|
|
}, {
|
|
"25": 25
|
|
}],
|
|
22: [function(require, module, exports) {
|
|
"use strict";
|
|
var $defineProperty = require(10),
|
|
hasPropertyDescriptors = function hasPropertyDescriptors() {
|
|
return !!$defineProperty
|
|
};
|
|
hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
|
|
if (!$defineProperty) return null;
|
|
try {
|
|
return 1 !== $defineProperty([], "length", {
|
|
value: 1
|
|
}).length
|
|
} catch (r) {
|
|
return !0
|
|
}
|
|
}, module.exports = hasPropertyDescriptors;
|
|
|
|
}, {
|
|
"10": 10
|
|
}],
|
|
25: [function(require, module, exports) {
|
|
"use strict";
|
|
module.exports = function hasSymbols() {
|
|
if ("function" != typeof Symbol || "function" != typeof Object
|
|
.getOwnPropertySymbols) return !1;
|
|
if ("symbol" == typeof Symbol.iterator) return !0;
|
|
var t = {},
|
|
e = Symbol("test"),
|
|
r = Object(e);
|
|
if ("string" == typeof e) return !1;
|
|
if ("[object Symbol]" !== Object.prototype.toString.call(e)) return !1;
|
|
if ("[object Symbol]" !== Object.prototype.toString.call(r)) return !1;
|
|
for (e in t[e] = 42, t) return !1;
|
|
if ("function" == typeof Object.keys && 0 !== Object.keys(t).length) return !1;
|
|
if ("function" == typeof Object.getOwnPropertyNames && 0 !== Object
|
|
.getOwnPropertyNames(t).length) return !1;
|
|
var o = Object.getOwnPropertySymbols(t);
|
|
if (1 !== o.length || o[0] !== e) return !1;
|
|
if (!Object.prototype.propertyIsEnumerable.call(t, e)) return !1;
|
|
if ("function" == typeof Object.getOwnPropertyDescriptor) {
|
|
var n = Object.getOwnPropertyDescriptor(t, e);
|
|
if (42 !== n.value || !0 !== n.enumerable) return !1
|
|
}
|
|
return !0
|
|
};
|
|
|
|
}, {}],
|
|
27: [function(require, module, exports) {
|
|
(function(global) {
|
|
(function() {
|
|
var hasMap = "function" == typeof Map && Map.prototype,
|
|
mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ?
|
|
Object.getOwnPropertyDescriptor(Map.prototype, "size") : null,
|
|
mapSize = hasMap && mapSizeDescriptor && "function" ==
|
|
typeof mapSizeDescriptor.get ? mapSizeDescriptor.get : null,
|
|
mapForEach = hasMap && Map.prototype.forEach,
|
|
hasSet = "function" == typeof Set && Set.prototype,
|
|
setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ?
|
|
Object.getOwnPropertyDescriptor(Set.prototype, "size") : null,
|
|
setSize = hasSet && setSizeDescriptor && "function" ==
|
|
typeof setSizeDescriptor.get ? setSizeDescriptor.get : null,
|
|
setForEach = hasSet && Set.prototype.forEach,
|
|
hasWeakMap = "function" == typeof WeakMap && WeakMap.prototype,
|
|
weakMapHas = hasWeakMap ? WeakMap.prototype.has : null,
|
|
hasWeakSet = "function" == typeof WeakSet && WeakSet.prototype,
|
|
weakSetHas = hasWeakSet ? WeakSet.prototype.has : null,
|
|
hasWeakRef = "function" == typeof WeakRef && WeakRef.prototype,
|
|
weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null,
|
|
booleanValueOf = Boolean.prototype.valueOf,
|
|
objectToString = Object.prototype.toString,
|
|
functionToString = Function.prototype.toString,
|
|
$match = String.prototype.match,
|
|
$slice = String.prototype.slice,
|
|
$replace = String.prototype.replace,
|
|
$toUpperCase = String.prototype.toUpperCase,
|
|
$toLowerCase = String.prototype.toLowerCase,
|
|
$test = RegExp.prototype.test,
|
|
$concat = Array.prototype.concat,
|
|
$join = Array.prototype.join,
|
|
$arrSlice = Array.prototype.slice,
|
|
$floor = Math.floor,
|
|
bigIntValueOf = "function" == typeof BigInt ? BigInt.prototype
|
|
.valueOf : null,
|
|
gOPS = Object.getOwnPropertySymbols,
|
|
symToString = "function" == typeof Symbol && "symbol" ==
|
|
typeof Symbol.iterator ? Symbol.prototype.toString : null,
|
|
hasShammedSymbols = "function" == typeof Symbol && "object" ==
|
|
typeof Symbol.iterator,
|
|
toStringTag = "function" == typeof Symbol && Symbol.toStringTag && (
|
|
Symbol.toStringTag, 1) ? Symbol.toStringTag : null,
|
|
isEnumerable = Object.prototype.propertyIsEnumerable,
|
|
gPO = ("function" == typeof Reflect ? Reflect.getPrototypeOf :
|
|
Object.getPrototypeOf) || ([].__proto__ === Array.prototype ?
|
|
function(t) {
|
|
return t.__proto__
|
|
} : null);
|
|
|
|
function addNumericSeparator(t, e) {
|
|
if (t === 1 / 0 || t === -1 / 0 || t != t || t && t > -1e3 && t <
|
|
1e3 || $test.call(/e/, e)) return e;
|
|
var r = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
|
|
if ("number" == typeof t) {
|
|
var n = t < 0 ? -$floor(-t) : $floor(t);
|
|
if (n !== t) {
|
|
var o = String(n),
|
|
i = $slice.call(e, o.length + 1);
|
|
return $replace.call(o, r, "$&_") + "." + $replace.call(
|
|
$replace.call(i, /([0-9]{3})/g, "$&_"), /_$/, "")
|
|
}
|
|
}
|
|
return $replace.call(e, r, "$&_")
|
|
}
|
|
var utilInspect = require(6),
|
|
inspectCustom = utilInspect.custom,
|
|
inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
|
|
|
|
function wrapQuotes(t, e, r) {
|
|
var n = "double" === (r.quoteStyle || e) ? '"' : "'";
|
|
return n + t + n
|
|
}
|
|
|
|
function quote(t) {
|
|
return $replace.call(String(t), /"/g, """)
|
|
}
|
|
|
|
function isArray(t) {
|
|
return !("[object Array]" !== toStr(t) || toStringTag && "object" ==
|
|
typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isDate(t) {
|
|
return !("[object Date]" !== toStr(t) || toStringTag && "object" ==
|
|
typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isRegExp(t) {
|
|
return !("[object RegExp]" !== toStr(t) || toStringTag &&
|
|
"object" == typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isError(t) {
|
|
return !("[object Error]" !== toStr(t) || toStringTag && "object" ==
|
|
typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isString(t) {
|
|
return !("[object String]" !== toStr(t) || toStringTag &&
|
|
"object" == typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isNumber(t) {
|
|
return !("[object Number]" !== toStr(t) || toStringTag &&
|
|
"object" == typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isBoolean(t) {
|
|
return !("[object Boolean]" !== toStr(t) || toStringTag &&
|
|
"object" == typeof t && toStringTag in t)
|
|
}
|
|
|
|
function isSymbol(t) {
|
|
if (hasShammedSymbols) return t && "object" == typeof t &&
|
|
t instanceof Symbol;
|
|
if ("symbol" == typeof t) return !0;
|
|
if (!t || "object" != typeof t || !symToString) return !1;
|
|
try {
|
|
return symToString.call(t), !0
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isBigInt(t) {
|
|
if (!t || "object" != typeof t || !bigIntValueOf) return !1;
|
|
try {
|
|
return bigIntValueOf.call(t), !0
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
module.exports = function inspect_(t, e, r, n) {
|
|
var o = e || {};
|
|
if (has(o, "quoteStyle") && "single" !== o.quoteStyle &&
|
|
"double" !== o.quoteStyle) throw new TypeError(
|
|
'option "quoteStyle" must be "single" or "double"');
|
|
if (has(o, "maxStringLength") && ("number" == typeof o
|
|
.maxStringLength ? o.maxStringLength < 0 && o
|
|
.maxStringLength !== 1 / 0 : null !== o.maxStringLength
|
|
)) throw new TypeError(
|
|
'option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'
|
|
);
|
|
var i = !has(o, "customInspect") || o.customInspect;
|
|
if ("boolean" != typeof i && "symbol" !== i)
|
|
throw new TypeError(
|
|
"option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"
|
|
);
|
|
if (has(o, "indent") && null !== o.indent && "\t" !== o
|
|
.indent && !(parseInt(o.indent, 10) === o.indent && o
|
|
.indent > 0)) throw new TypeError(
|
|
'option "indent" must be "\\t", an integer > 0, or `null`'
|
|
);
|
|
if (has(o, "numericSeparator") && "boolean" != typeof o
|
|
.numericSeparator) throw new TypeError(
|
|
'option "numericSeparator", if provided, must be `true` or `false`'
|
|
);
|
|
var a = o.numericSeparator;
|
|
if (void 0 === t) return "undefined";
|
|
if (null === t) return "null";
|
|
if ("boolean" == typeof t) return t ? "true" : "false";
|
|
if ("string" == typeof t) return inspectString(t, o);
|
|
if ("number" == typeof t) {
|
|
if (0 === t) return 1 / 0 / t > 0 ? "0" : "-0";
|
|
var c = String(t);
|
|
return a ? addNumericSeparator(t, c) : c
|
|
}
|
|
if ("bigint" == typeof t) {
|
|
var l = String(t) + "n";
|
|
return a ? addNumericSeparator(t, l) : l
|
|
}
|
|
var p = void 0 === o.depth ? 5 : o.depth;
|
|
if (void 0 === r && (r = 0), r >= p && p > 0 && "object" ==
|
|
typeof t) return isArray(t) ? "[Array]" : "[Object]";
|
|
var u = getIndent(o, r);
|
|
if (void 0 === n) n = [];
|
|
else if (indexOf(n, t) >= 0) return "[Circular]";
|
|
|
|
function inspect(t, e, i) {
|
|
if (e && (n = $arrSlice.call(n)).push(e), i) {
|
|
var a = {
|
|
depth: o.depth
|
|
};
|
|
return has(o, "quoteStyle") && (a.quoteStyle = o
|
|
.quoteStyle), inspect_(t, a, r + 1, n)
|
|
}
|
|
return inspect_(t, o, r + 1, n)
|
|
}
|
|
if ("function" == typeof t && !isRegExp(t)) {
|
|
var s = nameOf(t),
|
|
f = arrObjKeys(t, inspect);
|
|
return "[Function" + (s ? ": " + s : " (anonymous)") + "]" +
|
|
(f.length > 0 ? " { " + $join.call(f, ", ") + " }" : "")
|
|
}
|
|
if (isSymbol(t)) {
|
|
var y = hasShammedSymbols ? $replace.call(String(t),
|
|
/^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(
|
|
t);
|
|
return "object" != typeof t || hasShammedSymbols ? y :
|
|
markBoxed(y)
|
|
}
|
|
if (isElement(t)) {
|
|
for (var S = "<" + $toLowerCase.call(String(t.nodeName)),
|
|
g = t.attributes || [], m = 0; m < g.length; m++)
|
|
S += " " + g[m].name + "=" + wrapQuotes(quote(g[m]
|
|
.value), "double", o);
|
|
return S += ">", t.childNodes && t.childNodes.length && (
|
|
S += "..."), S + "</" + $toLowerCase.call(String(t
|
|
.nodeName)) + ">"
|
|
}
|
|
if (isArray(t)) {
|
|
if (0 === t.length) return "[]";
|
|
var b = arrObjKeys(t, inspect);
|
|
return u && !singleLineValues(b) ? "[" + indentedJoin(b,
|
|
u) + "]" : "[ " + $join.call(b, ", ") + " ]"
|
|
}
|
|
if (isError(t)) {
|
|
var h = arrObjKeys(t, inspect);
|
|
return "cause" in Error.prototype || !("cause" in t) ||
|
|
isEnumerable.call(t, "cause") ? 0 === h.length ? "[" +
|
|
String(t) + "]" : "{ [" + String(t) + "] " + $join.call(
|
|
h, ", ") + " }" : "{ [" + String(t) + "] " + $join
|
|
.call($concat.call("[cause]: " + inspect(t.cause), h),
|
|
", ") + " }"
|
|
}
|
|
if ("object" == typeof t && i) {
|
|
if (inspectSymbol && "function" == typeof t[
|
|
inspectSymbol] && utilInspect) return utilInspect(t, {
|
|
depth: p - r
|
|
});
|
|
if ("symbol" !== i && "function" == typeof t.inspect)
|
|
return t.inspect()
|
|
}
|
|
if (isMap(t)) {
|
|
var d = [];
|
|
return mapForEach && mapForEach.call(t, (function(e, r) {
|
|
d.push(inspect(r, t, !0) + " => " + inspect(
|
|
e, t))
|
|
})), collectionOf("Map", mapSize.call(t), d, u)
|
|
}
|
|
if (isSet(t)) {
|
|
var j = [];
|
|
return setForEach && setForEach.call(t, (function(e) {
|
|
j.push(inspect(e, t))
|
|
})), collectionOf("Set", setSize.call(t), j, u)
|
|
}
|
|
if (isWeakMap(t)) return weakCollectionOf("WeakMap");
|
|
if (isWeakSet(t)) return weakCollectionOf("WeakSet");
|
|
if (isWeakRef(t)) return weakCollectionOf("WeakRef");
|
|
if (isNumber(t)) return markBoxed(inspect(Number(t)));
|
|
if (isBigInt(t)) return markBoxed(inspect(bigIntValueOf.call(
|
|
t)));
|
|
if (isBoolean(t)) return markBoxed(booleanValueOf.call(t));
|
|
if (isString(t)) return markBoxed(inspect(String(t)));
|
|
if ("undefined" != typeof window && t === window)
|
|
return "{ [object Window] }";
|
|
if (t === global) return "{ [object globalThis] }";
|
|
if (!isDate(t) && !isRegExp(t)) {
|
|
var O = arrObjKeys(t, inspect),
|
|
w = gPO ? gPO(t) === Object.prototype :
|
|
t instanceof Object || t.constructor === Object,
|
|
$ = t instanceof Object ? "" : "null prototype",
|
|
k = !w && toStringTag && Object(t) === t &&
|
|
toStringTag in t ? $slice.call(toStr(t), 8, -1) : $ ?
|
|
"Object" : "",
|
|
v = (w || "function" != typeof t.constructor ? "" : t
|
|
.constructor.name ? t.constructor.name + " " : "") +
|
|
(k || $ ? "[" + $join.call($concat.call([], k || [],
|
|
$ || []), ": ") + "] " : "");
|
|
return 0 === O.length ? v + "{}" : u ? v + "{" +
|
|
indentedJoin(O, u) + "}" : v + "{ " + $join.call(O,
|
|
", ") + " }"
|
|
}
|
|
return String(t)
|
|
};
|
|
var hasOwn = Object.prototype.hasOwnProperty || function(t) {
|
|
return t in this
|
|
};
|
|
|
|
function has(t, e) {
|
|
return hasOwn.call(t, e)
|
|
}
|
|
|
|
function toStr(t) {
|
|
return objectToString.call(t)
|
|
}
|
|
|
|
function nameOf(t) {
|
|
if (t.name) return t.name;
|
|
var e = $match.call(functionToString.call(t),
|
|
/^function\s*([\w$]+)/);
|
|
return e ? e[1] : null
|
|
}
|
|
|
|
function indexOf(t, e) {
|
|
if (t.indexOf) return t.indexOf(e);
|
|
for (var r = 0, n = t.length; r < n; r++)
|
|
if (t[r] === e) return r;
|
|
return -1
|
|
}
|
|
|
|
function isMap(t) {
|
|
if (!mapSize || !t || "object" != typeof t) return !1;
|
|
try {
|
|
mapSize.call(t);
|
|
try {
|
|
setSize.call(t)
|
|
} catch (t) {
|
|
return !0
|
|
}
|
|
return t instanceof Map
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isWeakMap(t) {
|
|
if (!weakMapHas || !t || "object" != typeof t) return !1;
|
|
try {
|
|
weakMapHas.call(t, weakMapHas);
|
|
try {
|
|
weakSetHas.call(t, weakSetHas)
|
|
} catch (t) {
|
|
return !0
|
|
}
|
|
return t instanceof WeakMap
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isWeakRef(t) {
|
|
if (!weakRefDeref || !t || "object" != typeof t) return !1;
|
|
try {
|
|
return weakRefDeref.call(t), !0
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isSet(t) {
|
|
if (!setSize || !t || "object" != typeof t) return !1;
|
|
try {
|
|
setSize.call(t);
|
|
try {
|
|
mapSize.call(t)
|
|
} catch (t) {
|
|
return !0
|
|
}
|
|
return t instanceof Set
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isWeakSet(t) {
|
|
if (!weakSetHas || !t || "object" != typeof t) return !1;
|
|
try {
|
|
weakSetHas.call(t, weakSetHas);
|
|
try {
|
|
weakMapHas.call(t, weakMapHas)
|
|
} catch (t) {
|
|
return !0
|
|
}
|
|
return t instanceof WeakSet
|
|
} catch (t) {}
|
|
return !1
|
|
}
|
|
|
|
function isElement(t) {
|
|
return !(!t || "object" != typeof t) && ("undefined" !=
|
|
typeof HTMLElement && t instanceof HTMLElement ||
|
|
"string" == typeof t.nodeName && "function" == typeof t
|
|
.getAttribute)
|
|
}
|
|
|
|
function inspectString(t, e) {
|
|
if (t.length > e.maxStringLength) {
|
|
var r = t.length - e.maxStringLength,
|
|
n = "... " + r + " more character" + (r > 1 ? "s" : "");
|
|
return inspectString($slice.call(t, 0, e.maxStringLength), e) +
|
|
n
|
|
}
|
|
return wrapQuotes($replace.call($replace.call(t, /(['\\])/g,
|
|
"\\$1"), /[\x00-\x1f]/g, lowbyte), "single", e)
|
|
}
|
|
|
|
function lowbyte(t) {
|
|
var e = t.charCodeAt(0),
|
|
r = {
|
|
8: "b",
|
|
9: "t",
|
|
10: "n",
|
|
12: "f",
|
|
13: "r"
|
|
} [e];
|
|
return r ? "\\" + r : "\\x" + (e < 16 ? "0" : "") + $toUpperCase
|
|
.call(e.toString(16))
|
|
}
|
|
|
|
function markBoxed(t) {
|
|
return "Object(" + t + ")"
|
|
}
|
|
|
|
function weakCollectionOf(t) {
|
|
return t + " { ? }"
|
|
}
|
|
|
|
function collectionOf(t, e, r, n) {
|
|
return t + " (" + e + ") {" + (n ? indentedJoin(r, n) : $join.call(
|
|
r, ", ")) + "}"
|
|
}
|
|
|
|
function singleLineValues(t) {
|
|
for (var e = 0; e < t.length; e++)
|
|
if (indexOf(t[e], "\n") >= 0) return !1;
|
|
return !0
|
|
}
|
|
|
|
function getIndent(t, e) {
|
|
var r;
|
|
if ("\t" === t.indent) r = "\t";
|
|
else {
|
|
if (!("number" == typeof t.indent && t.indent > 0)) return null;
|
|
r = $join.call(Array(t.indent + 1), " ")
|
|
}
|
|
return {
|
|
base: r,
|
|
prev: $join.call(Array(e + 1), r)
|
|
}
|
|
}
|
|
|
|
function indentedJoin(t, e) {
|
|
if (0 === t.length) return "";
|
|
var r = "\n" + e.prev + e.base;
|
|
return r + $join.call(t, "," + r) + "\n" + e.prev
|
|
}
|
|
|
|
function arrObjKeys(t, e) {
|
|
var r = isArray(t),
|
|
n = [];
|
|
if (r) {
|
|
n.length = t.length;
|
|
for (var o = 0; o < t.length; o++) n[o] = has(t, o) ? e(t[o],
|
|
t) : ""
|
|
}
|
|
var i, a = "function" == typeof gOPS ? gOPS(t) : [];
|
|
if (hasShammedSymbols) {
|
|
i = {};
|
|
for (var c = 0; c < a.length; c++) i["$" + a[c]] = a[c]
|
|
}
|
|
for (var l in t) has(t, l) && (r && String(Number(l)) === l && l < t
|
|
.length || hasShammedSymbols && i["$" +
|
|
l] instanceof Symbol || ($test.call(/[^\w$]/, l) ? n.push(e(
|
|
l, t) + ": " + e(t[l], t)) : n.push(l + ": " + e(t[
|
|
l], t))));
|
|
if ("function" == typeof gOPS)
|
|
for (var p = 0; p < a.length; p++) isEnumerable.call(t, a[p]) &&
|
|
n.push("[" + e(a[p]) + "]: " + e(t[a[p]], t));
|
|
return n
|
|
}
|
|
|
|
}).call(this)
|
|
}).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ?
|
|
self : typeof window !== "undefined" ? window : {})
|
|
}, {
|
|
"6": 6
|
|
}]
|
|
}, {}, [2])(2)
|
|
}
|
|
export default f() |