2366 lines
88 KiB
JavaScript
2366 lines
88 KiB
JavaScript
(function (f) {
|
|
if (typeof exports === 'object' && typeof module !== 'undefined') {
|
|
module.exports = f();
|
|
} else if (typeof define === 'function' && define.amd) {
|
|
define([], f);
|
|
} else {
|
|
var g;
|
|
if (typeof window !== 'undefined') {
|
|
g = window;
|
|
} else if (typeof global !== 'undefined') {
|
|
g = global;
|
|
} else if (typeof self !== 'undefined') {
|
|
g = self;
|
|
} else {
|
|
g = this;
|
|
}
|
|
g.Qs = f();
|
|
}
|
|
})(function () {
|
|
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,
|
|
strictDepth: !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 = { __proto__: null },
|
|
a = t.ignoreQueryPrefix ? e.replace(/^\?/, '') : e;
|
|
a = a.replace(/%5B/gi, '[').replace(/%5D/gi, ']');
|
|
var i,
|
|
o = t.parameterLimit === 1 / 0 ? void 0 : t.parameterLimit,
|
|
l = a.split(t.delimiter, o),
|
|
s = -1,
|
|
n = t.charset;
|
|
if (t.charsetSentinel)
|
|
for (i = 0; i < l.length; ++i)
|
|
0 === l[i].indexOf('utf8=') &&
|
|
(l[i] === charsetSentinel ?
|
|
(n = 'utf-8')
|
|
: l[i] === isoSentinel && (n = 'iso-8859-1'),
|
|
(s = i),
|
|
(i = l.length));
|
|
for (i = 0; i < l.length; ++i)
|
|
if (i !== s) {
|
|
var p,
|
|
c,
|
|
d = l[i],
|
|
u = d.indexOf(']='),
|
|
f = -1 === u ? d.indexOf('=') : u + 1;
|
|
-1 === f ?
|
|
((p = t.decoder(d, defaults.decoder, n, 'key')),
|
|
(c = t.strictNullHandling ? null : ''))
|
|
: ((p = t.decoder(d.slice(0, f), defaults.decoder, n, 'key')),
|
|
(c = utils.maybeMap(
|
|
parseArrayValue(d.slice(f + 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 y = has.call(r, p);
|
|
y && 'combine' === t.duplicates ?
|
|
(r[p] = utils.combine(r[p], c))
|
|
: (y && 'last' !== t.duplicates) || (r[p] = c);
|
|
}
|
|
return r;
|
|
},
|
|
parseObject = function (e, t, r, a) {
|
|
for (
|
|
var i = a ? t : parseArrayValue(t, r), o = e.length - 1;
|
|
o >= 0;
|
|
--o
|
|
) {
|
|
var l,
|
|
s = e[o];
|
|
if ('[]' === s && r.parseArrays)
|
|
l =
|
|
(
|
|
r.allowEmptyArrays &&
|
|
('' === i || (r.strictNullHandling && null === i))
|
|
) ?
|
|
[]
|
|
: [].concat(i);
|
|
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] = i)
|
|
: '__proto__' !== p && (l[p] = i)
|
|
: (l = { 0: i });
|
|
}
|
|
i = l;
|
|
}
|
|
return i;
|
|
},
|
|
parseKeys = function parseQueryStringKeys(e, t, r, a) {
|
|
if (e) {
|
|
var i = r.allowDots ? e.replace(/\.([^.[]+)/g, '[$1]') : e,
|
|
o = /(\[[^[\]]*])/g,
|
|
l = r.depth > 0 && /(\[[^[\]]*])/.exec(i),
|
|
s = l ? i.slice(0, l.index) : i,
|
|
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 = o.exec(i)) && p < r.depth;
|
|
|
|
) {
|
|
if (
|
|
((p += 1),
|
|
!r.plainObjects &&
|
|
has.call(Object.prototype, l[1].slice(1, -1)) &&
|
|
!r.allowPrototypes)
|
|
)
|
|
return;
|
|
n.push(l[1]);
|
|
}
|
|
if (l) {
|
|
if (!0 === r.strictDepth)
|
|
throw new RangeError(
|
|
'Input depth exceeded depth option of ' +
|
|
r.depth +
|
|
' and strictDepth is true'
|
|
);
|
|
n.push('[' + i.slice(l.index) + ']');
|
|
}
|
|
return 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,
|
|
strictDepth:
|
|
'boolean' == typeof e.strictDepth ?
|
|
!!e.strictDepth
|
|
: defaults.strictDepth,
|
|
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,
|
|
i = r.plainObjects ? Object.create(null) : {},
|
|
o = Object.keys(a),
|
|
l = 0;
|
|
l < o.length;
|
|
++l
|
|
) {
|
|
var s = o[l],
|
|
n = parseKeys(s, a[s], r, 'string' == typeof e);
|
|
i = utils.merge(i, n, r);
|
|
}
|
|
return !0 === r.allowSparse ? i : utils.compact(i);
|
|
};
|
|
},
|
|
{ 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 f = nameOf(t),
|
|
s = arrObjKeys(t, inspect);
|
|
return (
|
|
'[Function' +
|
|
(f ? ': ' + f : ' (anonymous)') +
|
|
']' +
|
|
(s.length > 0 ? ' { ' + $join.call(s, ', ') + ' }' : '')
|
|
);
|
|
}
|
|
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 || [],
|
|
b = 0;
|
|
b < g.length;
|
|
b++
|
|
)
|
|
S +=
|
|
' ' +
|
|
g[b].name +
|
|
'=' +
|
|
wrapQuotes(quote(g[b].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 m = arrObjKeys(t, inspect);
|
|
return u && !singleLineValues(m) ?
|
|
'[' + indentedJoin(m, u) + ']'
|
|
: '[ ' + $join.call(m, ', ') + ' ]';
|
|
}
|
|
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 (
|
|
('undefined' != typeof globalThis && t === globalThis) ||
|
|
('undefined' != typeof global && 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);
|
|
});
|