3580 lines
91 KiB
JavaScript
3580 lines
91 KiB
JavaScript
/*!
|
|
* https://github.com/paulmillr/es6-shim
|
|
* @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)
|
|
* and contributors, MIT License
|
|
* es6-shim: v0.35.4
|
|
* see https://github.com/paulmillr/es6-shim/blob/0.35.3/LICENSE
|
|
* Details and documentation:
|
|
* https://github.com/paulmillr/es6-shim/
|
|
*/
|
|
(function (e, t) {
|
|
if (typeof define === 'function' && define.amd) {
|
|
define(t);
|
|
} else if (typeof exports === 'object') {
|
|
module.exports = t();
|
|
} else {
|
|
e.returnExports = t();
|
|
}
|
|
})(this, function () {
|
|
'use strict';
|
|
var e = Function.call.bind(Function.apply);
|
|
var t = Function.call.bind(Function.call);
|
|
var r = Array.isArray;
|
|
var n = Object.keys;
|
|
var o = function notThunker(t) {
|
|
return function notThunk() {
|
|
return !e(t, this, arguments);
|
|
};
|
|
};
|
|
var i = function (e) {
|
|
try {
|
|
e();
|
|
return false;
|
|
} catch (t) {
|
|
return true;
|
|
}
|
|
};
|
|
var a = function valueOrFalseIfThrows(e) {
|
|
try {
|
|
return e();
|
|
} catch (t) {
|
|
return false;
|
|
}
|
|
};
|
|
var u = o(i);
|
|
var f = function () {
|
|
return !i(function () {
|
|
return Object.defineProperty({}, 'x', { get: function () {} });
|
|
});
|
|
};
|
|
var s = !!Object.defineProperty && f();
|
|
var c = function foo() {}.name === 'foo';
|
|
var l = Function.call.bind(Array.prototype.forEach);
|
|
var p = Function.call.bind(Array.prototype.reduce);
|
|
var v = Function.call.bind(Array.prototype.filter);
|
|
var y = Function.call.bind(Array.prototype.some);
|
|
var h = function (e, t, r, n) {
|
|
if (!n && t in e) {
|
|
return;
|
|
}
|
|
if (s) {
|
|
Object.defineProperty(e, t, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true,
|
|
value: r,
|
|
});
|
|
} else {
|
|
e[t] = r;
|
|
}
|
|
};
|
|
var b = function (e, t, r) {
|
|
l(n(t), function (n) {
|
|
var o = t[n];
|
|
h(e, n, o, !!r);
|
|
});
|
|
};
|
|
var g = Function.call.bind(Object.prototype.toString);
|
|
var d =
|
|
typeof /abc/ === 'function'
|
|
? function IsCallableSlow(e) {
|
|
return typeof e === 'function' && g(e) === '[object Function]';
|
|
}
|
|
: function IsCallableFast(e) {
|
|
return typeof e === 'function';
|
|
};
|
|
var m = {
|
|
getter: function (e, t, r) {
|
|
if (!s) {
|
|
throw new TypeError('getters require true ES5 support');
|
|
}
|
|
Object.defineProperty(e, t, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
get: r,
|
|
});
|
|
},
|
|
proxy: function (e, t, r) {
|
|
if (!s) {
|
|
throw new TypeError('getters require true ES5 support');
|
|
}
|
|
var n = Object.getOwnPropertyDescriptor(e, t);
|
|
Object.defineProperty(r, t, {
|
|
configurable: n.configurable,
|
|
enumerable: n.enumerable,
|
|
get: function getKey() {
|
|
return e[t];
|
|
},
|
|
set: function setKey(r) {
|
|
e[t] = r;
|
|
},
|
|
});
|
|
},
|
|
redefine: function (e, t, r) {
|
|
if (s) {
|
|
var n = Object.getOwnPropertyDescriptor(e, t);
|
|
n.value = r;
|
|
Object.defineProperty(e, t, n);
|
|
} else {
|
|
e[t] = r;
|
|
}
|
|
},
|
|
defineByDescriptor: function (e, t, r) {
|
|
if (s) {
|
|
Object.defineProperty(e, t, r);
|
|
} else if ('value' in r) {
|
|
e[t] = r.value;
|
|
}
|
|
},
|
|
preserveToString: function (e, t) {
|
|
if (t && d(t.toString)) {
|
|
h(e, 'toString', t.toString.bind(t), true);
|
|
}
|
|
},
|
|
};
|
|
var O =
|
|
Object.create ||
|
|
function (e, t) {
|
|
var r = function Prototype() {};
|
|
r.prototype = e;
|
|
var o = new r();
|
|
if (typeof t !== 'undefined') {
|
|
n(t).forEach(function (e) {
|
|
m.defineByDescriptor(o, e, t[e]);
|
|
});
|
|
}
|
|
return o;
|
|
};
|
|
var w = function (e, t) {
|
|
if (!Object.setPrototypeOf) {
|
|
return false;
|
|
}
|
|
return a(function () {
|
|
var r = function Subclass(t) {
|
|
var r = new e(t);
|
|
Object.setPrototypeOf(r, Subclass.prototype);
|
|
return r;
|
|
};
|
|
Object.setPrototypeOf(r, e);
|
|
r.prototype = O(e.prototype, { constructor: { value: r } });
|
|
return t(r);
|
|
});
|
|
};
|
|
var j = function () {
|
|
if (typeof self !== 'undefined') {
|
|
return self;
|
|
}
|
|
if (typeof window !== 'undefined') {
|
|
return window;
|
|
}
|
|
if (typeof global !== 'undefined') {
|
|
return global;
|
|
}
|
|
throw new Error('unable to locate global object');
|
|
};
|
|
var S = j();
|
|
var T = S.isFinite;
|
|
var I = Function.call.bind(String.prototype.indexOf);
|
|
var E = Function.apply.bind(Array.prototype.indexOf);
|
|
var P = Function.call.bind(Array.prototype.concat);
|
|
var C = Function.call.bind(String.prototype.slice);
|
|
var M = Function.call.bind(Array.prototype.push);
|
|
var x = Function.apply.bind(Array.prototype.push);
|
|
var N = Function.call.bind(Array.prototype.shift);
|
|
var A = Math.max;
|
|
var R = Math.min;
|
|
var _ = Math.floor;
|
|
var k = Math.abs;
|
|
var L = Math.exp;
|
|
var F = Math.log;
|
|
var D = Math.sqrt;
|
|
var z = Function.call.bind(Object.prototype.hasOwnProperty);
|
|
var q;
|
|
var W = function () {};
|
|
var G = S.Map;
|
|
var H = G && G.prototype['delete'];
|
|
var V = G && G.prototype.get;
|
|
var B = G && G.prototype.has;
|
|
var U = G && G.prototype.set;
|
|
var $ = S.Symbol || {};
|
|
var J = $.species || '@@species';
|
|
var X =
|
|
Number.isNaN ||
|
|
function isNaN(e) {
|
|
return e !== e;
|
|
};
|
|
var K =
|
|
Number.isFinite ||
|
|
function isFinite(e) {
|
|
return typeof e === 'number' && T(e);
|
|
};
|
|
var Z = d(Math.sign)
|
|
? Math.sign
|
|
: function sign(e) {
|
|
var t = Number(e);
|
|
if (t === 0) {
|
|
return t;
|
|
}
|
|
if (X(t)) {
|
|
return t;
|
|
}
|
|
return t < 0 ? -1 : 1;
|
|
};
|
|
var Y = function log1p(e) {
|
|
var t = Number(e);
|
|
if (t < -1 || X(t)) {
|
|
return NaN;
|
|
}
|
|
if (t === 0 || t === Infinity) {
|
|
return t;
|
|
}
|
|
if (t === -1) {
|
|
return -Infinity;
|
|
}
|
|
return 1 + t - 1 === 0 ? t : t * (F(1 + t) / (1 + t - 1));
|
|
};
|
|
var Q = function isArguments(e) {
|
|
return g(e) === '[object Arguments]';
|
|
};
|
|
var ee = function isArguments(e) {
|
|
return (
|
|
e !== null &&
|
|
typeof e === 'object' &&
|
|
typeof e.length === 'number' &&
|
|
e.length >= 0 &&
|
|
g(e) !== '[object Array]' &&
|
|
g(e.callee) === '[object Function]'
|
|
);
|
|
};
|
|
var te = Q(arguments) ? Q : ee;
|
|
var re = {
|
|
primitive: function (e) {
|
|
return e === null || (typeof e !== 'function' && typeof e !== 'object');
|
|
},
|
|
string: function (e) {
|
|
return g(e) === '[object String]';
|
|
},
|
|
regex: function (e) {
|
|
return g(e) === '[object RegExp]';
|
|
},
|
|
symbol: function (e) {
|
|
return typeof S.Symbol === 'function' && typeof e === 'symbol';
|
|
},
|
|
};
|
|
var ne = function overrideNative(e, t, r) {
|
|
var n = e[t];
|
|
h(e, t, r, true);
|
|
m.preserveToString(e[t], n);
|
|
};
|
|
var oe = typeof $ === 'function' && typeof $['for'] === 'function' && re.symbol($());
|
|
var ie = re.symbol($.iterator) ? $.iterator : '_es6-shim iterator_';
|
|
if (S.Set && typeof new S.Set()['@@iterator'] === 'function') {
|
|
ie = '@@iterator';
|
|
}
|
|
if (!S.Reflect) {
|
|
h(S, 'Reflect', {}, true);
|
|
}
|
|
var ae = S.Reflect;
|
|
var ue = String;
|
|
var fe = typeof document === 'undefined' || !document ? null : document.all;
|
|
var se =
|
|
fe == null
|
|
? function isNullOrUndefined(e) {
|
|
return e == null;
|
|
}
|
|
: function isNullOrUndefinedAndNotDocumentAll(e) {
|
|
return e == null && e !== fe;
|
|
};
|
|
var ce = {
|
|
Call: function Call(t, r) {
|
|
var n = arguments.length > 2 ? arguments[2] : [];
|
|
if (!ce.IsCallable(t)) {
|
|
throw new TypeError(t + ' is not a function');
|
|
}
|
|
return e(t, r, n);
|
|
},
|
|
RequireObjectCoercible: function (e, t) {
|
|
if (se(e)) {
|
|
throw new TypeError(t || 'Cannot call method on ' + e);
|
|
}
|
|
return e;
|
|
},
|
|
TypeIsObject: function (e) {
|
|
if (e === void 0 || e === null || e === true || e === false) {
|
|
return false;
|
|
}
|
|
return typeof e === 'function' || typeof e === 'object' || e === fe;
|
|
},
|
|
ToObject: function (e, t) {
|
|
return Object(ce.RequireObjectCoercible(e, t));
|
|
},
|
|
IsCallable: d,
|
|
IsConstructor: function (e) {
|
|
return ce.IsCallable(e);
|
|
},
|
|
ToInt32: function (e) {
|
|
return ce.ToNumber(e) >> 0;
|
|
},
|
|
ToUint32: function (e) {
|
|
return ce.ToNumber(e) >>> 0;
|
|
},
|
|
ToNumber: function (e) {
|
|
if (g(e) === '[object Symbol]') {
|
|
throw new TypeError('Cannot convert a Symbol value to a number');
|
|
}
|
|
return +e;
|
|
},
|
|
ToInteger: function (e) {
|
|
var t = ce.ToNumber(e);
|
|
if (X(t)) {
|
|
return 0;
|
|
}
|
|
if (t === 0 || !K(t)) {
|
|
return t;
|
|
}
|
|
return (t > 0 ? 1 : -1) * _(k(t));
|
|
},
|
|
ToLength: function (e) {
|
|
var t = ce.ToInteger(e);
|
|
if (t <= 0) {
|
|
return 0;
|
|
}
|
|
if (t > Number.MAX_SAFE_INTEGER) {
|
|
return Number.MAX_SAFE_INTEGER;
|
|
}
|
|
return t;
|
|
},
|
|
SameValue: function (e, t) {
|
|
if (e === t) {
|
|
if (e === 0) {
|
|
return 1 / e === 1 / t;
|
|
}
|
|
return true;
|
|
}
|
|
return X(e) && X(t);
|
|
},
|
|
SameValueZero: function (e, t) {
|
|
return e === t || (X(e) && X(t));
|
|
},
|
|
IsIterable: function (e) {
|
|
return ce.TypeIsObject(e) && (typeof e[ie] !== 'undefined' || te(e));
|
|
},
|
|
GetIterator: function (e) {
|
|
if (te(e)) {
|
|
return new q(e, 'value');
|
|
}
|
|
var t = ce.GetMethod(e, ie);
|
|
if (!ce.IsCallable(t)) {
|
|
throw new TypeError('value is not an iterable');
|
|
}
|
|
var r = ce.Call(t, e);
|
|
if (!ce.TypeIsObject(r)) {
|
|
throw new TypeError('bad iterator');
|
|
}
|
|
return r;
|
|
},
|
|
GetMethod: function (e, t) {
|
|
var r = ce.ToObject(e)[t];
|
|
if (se(r)) {
|
|
return void 0;
|
|
}
|
|
if (!ce.IsCallable(r)) {
|
|
throw new TypeError('Method not callable: ' + t);
|
|
}
|
|
return r;
|
|
},
|
|
IteratorComplete: function (e) {
|
|
return !!e.done;
|
|
},
|
|
IteratorClose: function (e, t) {
|
|
var r = ce.GetMethod(e, 'return');
|
|
if (r === void 0) {
|
|
return;
|
|
}
|
|
var n, o;
|
|
try {
|
|
n = ce.Call(r, e);
|
|
} catch (i) {
|
|
o = i;
|
|
}
|
|
if (t) {
|
|
return;
|
|
}
|
|
if (o) {
|
|
throw o;
|
|
}
|
|
if (!ce.TypeIsObject(n)) {
|
|
throw new TypeError("Iterator's return method returned a non-object.");
|
|
}
|
|
},
|
|
IteratorNext: function (e) {
|
|
var t = arguments.length > 1 ? e.next(arguments[1]) : e.next();
|
|
if (!ce.TypeIsObject(t)) {
|
|
throw new TypeError('bad iterator');
|
|
}
|
|
return t;
|
|
},
|
|
IteratorStep: function (e) {
|
|
var t = ce.IteratorNext(e);
|
|
var r = ce.IteratorComplete(t);
|
|
return r ? false : t;
|
|
},
|
|
Construct: function (e, t, r, n) {
|
|
var o = typeof r === 'undefined' ? e : r;
|
|
if (!n && ae.construct) {
|
|
return ae.construct(e, t, o);
|
|
}
|
|
var i = o.prototype;
|
|
if (!ce.TypeIsObject(i)) {
|
|
i = Object.prototype;
|
|
}
|
|
var a = O(i);
|
|
var u = ce.Call(e, a, t);
|
|
return ce.TypeIsObject(u) ? u : a;
|
|
},
|
|
SpeciesConstructor: function (e, t) {
|
|
var r = e.constructor;
|
|
if (r === void 0) {
|
|
return t;
|
|
}
|
|
if (!ce.TypeIsObject(r)) {
|
|
throw new TypeError('Bad constructor');
|
|
}
|
|
var n = r[J];
|
|
if (se(n)) {
|
|
return t;
|
|
}
|
|
if (!ce.IsConstructor(n)) {
|
|
throw new TypeError('Bad @@species');
|
|
}
|
|
return n;
|
|
},
|
|
CreateHTML: function (e, t, r, n) {
|
|
var o = ce.ToString(e);
|
|
var i = '<' + t;
|
|
if (r !== '') {
|
|
var a = ce.ToString(n);
|
|
var u = a.replace(/"/g, '"');
|
|
i += ' ' + r + '="' + u + '"';
|
|
}
|
|
var f = i + '>';
|
|
var s = f + o;
|
|
return s + '</' + t + '>';
|
|
},
|
|
IsRegExp: function IsRegExp(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return false;
|
|
}
|
|
var t = e[$.match];
|
|
if (typeof t !== 'undefined') {
|
|
return !!t;
|
|
}
|
|
return re.regex(e);
|
|
},
|
|
ToString: function ToString(e) {
|
|
return ue(e);
|
|
},
|
|
};
|
|
if (s && oe) {
|
|
var le = function defineWellKnownSymbol(e) {
|
|
if (re.symbol($[e])) {
|
|
return $[e];
|
|
}
|
|
var t = $['for']('Symbol.' + e);
|
|
Object.defineProperty($, e, {
|
|
configurable: false,
|
|
enumerable: false,
|
|
writable: false,
|
|
value: t,
|
|
});
|
|
return t;
|
|
};
|
|
if (!re.symbol($.search)) {
|
|
var pe = le('search');
|
|
var ve = String.prototype.search;
|
|
h(RegExp.prototype, pe, function search(e) {
|
|
return ce.Call(ve, e, [this]);
|
|
});
|
|
var ye = function search(e) {
|
|
var t = ce.RequireObjectCoercible(this);
|
|
if (!se(e)) {
|
|
var r = ce.GetMethod(e, pe);
|
|
if (typeof r !== 'undefined') {
|
|
return ce.Call(r, e, [t]);
|
|
}
|
|
}
|
|
return ce.Call(ve, t, [ce.ToString(e)]);
|
|
};
|
|
ne(String.prototype, 'search', ye);
|
|
}
|
|
if (!re.symbol($.replace)) {
|
|
var he = le('replace');
|
|
var be = String.prototype.replace;
|
|
h(RegExp.prototype, he, function replace(e, t) {
|
|
return ce.Call(be, e, [this, t]);
|
|
});
|
|
var ge = function replace(e, t) {
|
|
var r = ce.RequireObjectCoercible(this);
|
|
if (!se(e)) {
|
|
var n = ce.GetMethod(e, he);
|
|
if (typeof n !== 'undefined') {
|
|
return ce.Call(n, e, [r, t]);
|
|
}
|
|
}
|
|
return ce.Call(be, r, [ce.ToString(e), t]);
|
|
};
|
|
ne(String.prototype, 'replace', ge);
|
|
}
|
|
if (!re.symbol($.split)) {
|
|
var de = le('split');
|
|
var me = String.prototype.split;
|
|
h(RegExp.prototype, de, function split(e, t) {
|
|
return ce.Call(me, e, [this, t]);
|
|
});
|
|
var Oe = function split(e, t) {
|
|
var r = ce.RequireObjectCoercible(this);
|
|
if (!se(e)) {
|
|
var n = ce.GetMethod(e, de);
|
|
if (typeof n !== 'undefined') {
|
|
return ce.Call(n, e, [r, t]);
|
|
}
|
|
}
|
|
return ce.Call(me, r, [ce.ToString(e), t]);
|
|
};
|
|
ne(String.prototype, 'split', Oe);
|
|
}
|
|
var we = re.symbol($.match);
|
|
var je =
|
|
we &&
|
|
(function () {
|
|
var e = {};
|
|
e[$.match] = function () {
|
|
return 42;
|
|
};
|
|
return 'a'.match(e) !== 42;
|
|
})();
|
|
if (!we || je) {
|
|
var Se = le('match');
|
|
var Te = String.prototype.match;
|
|
h(RegExp.prototype, Se, function match(e) {
|
|
return ce.Call(Te, e, [this]);
|
|
});
|
|
var Ie = function match(e) {
|
|
var t = ce.RequireObjectCoercible(this);
|
|
if (!se(e)) {
|
|
var r = ce.GetMethod(e, Se);
|
|
if (typeof r !== 'undefined') {
|
|
return ce.Call(r, e, [t]);
|
|
}
|
|
}
|
|
return ce.Call(Te, t, [ce.ToString(e)]);
|
|
};
|
|
ne(String.prototype, 'match', Ie);
|
|
}
|
|
}
|
|
var Ee = function wrapConstructor(e, t, r) {
|
|
m.preserveToString(t, e);
|
|
if (Object.setPrototypeOf) {
|
|
Object.setPrototypeOf(e, t);
|
|
}
|
|
if (s) {
|
|
l(Object.getOwnPropertyNames(e), function (n) {
|
|
if (n in W || r[n]) {
|
|
return;
|
|
}
|
|
m.proxy(e, n, t);
|
|
});
|
|
} else {
|
|
l(Object.keys(e), function (n) {
|
|
if (n in W || r[n]) {
|
|
return;
|
|
}
|
|
t[n] = e[n];
|
|
});
|
|
}
|
|
t.prototype = e.prototype;
|
|
m.redefine(e.prototype, 'constructor', t);
|
|
};
|
|
var Pe = function () {
|
|
return this;
|
|
};
|
|
var Ce = function (e) {
|
|
if (s && !z(e, J)) {
|
|
m.getter(e, J, Pe);
|
|
}
|
|
};
|
|
var Me = function (e, t) {
|
|
var r =
|
|
t ||
|
|
function iterator() {
|
|
return this;
|
|
};
|
|
h(e, ie, r);
|
|
if (!e[ie] && re.symbol(ie)) {
|
|
e[ie] = r;
|
|
}
|
|
};
|
|
var xe = function createDataProperty(e, t, r) {
|
|
if (s) {
|
|
Object.defineProperty(e, t, {
|
|
configurable: true,
|
|
enumerable: true,
|
|
writable: true,
|
|
value: r,
|
|
});
|
|
} else {
|
|
e[t] = r;
|
|
}
|
|
};
|
|
var Ne = function createDataPropertyOrThrow(e, t, r) {
|
|
xe(e, t, r);
|
|
if (!ce.SameValue(e[t], r)) {
|
|
throw new TypeError('property is nonconfigurable');
|
|
}
|
|
};
|
|
var Ae = function (e, t, r, n) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
throw new TypeError('Constructor requires `new`: ' + t.name);
|
|
}
|
|
var o = t.prototype;
|
|
if (!ce.TypeIsObject(o)) {
|
|
o = r;
|
|
}
|
|
var i = O(o);
|
|
for (var a in n) {
|
|
if (z(n, a)) {
|
|
var u = n[a];
|
|
h(i, a, u, true);
|
|
}
|
|
}
|
|
return i;
|
|
};
|
|
if (String.fromCodePoint && String.fromCodePoint.length !== 1) {
|
|
var Re = String.fromCodePoint;
|
|
ne(String, 'fromCodePoint', function fromCodePoint(e) {
|
|
return ce.Call(Re, this, arguments);
|
|
});
|
|
}
|
|
var _e = {
|
|
fromCodePoint: function fromCodePoint(e) {
|
|
var t = [];
|
|
var r;
|
|
for (var n = 0, o = arguments.length; n < o; n++) {
|
|
r = Number(arguments[n]);
|
|
if (!ce.SameValue(r, ce.ToInteger(r)) || r < 0 || r > 1114111) {
|
|
throw new RangeError('Invalid code point ' + r);
|
|
}
|
|
if (r < 65536) {
|
|
M(t, String.fromCharCode(r));
|
|
} else {
|
|
r -= 65536;
|
|
M(t, String.fromCharCode((r >> 10) + 55296));
|
|
M(t, String.fromCharCode((r % 1024) + 56320));
|
|
}
|
|
}
|
|
return t.join('');
|
|
},
|
|
raw: function raw(e) {
|
|
var t = ce.ToObject(e, 'bad callSite');
|
|
var r = ce.ToObject(t.raw, 'bad raw value');
|
|
var n = r.length;
|
|
var o = ce.ToLength(n);
|
|
if (o <= 0) {
|
|
return '';
|
|
}
|
|
var i = [];
|
|
var a = 0;
|
|
var u, f, s, c;
|
|
while (a < o) {
|
|
u = ce.ToString(a);
|
|
s = ce.ToString(r[u]);
|
|
M(i, s);
|
|
if (a + 1 >= o) {
|
|
break;
|
|
}
|
|
f = a + 1 < arguments.length ? arguments[a + 1] : '';
|
|
c = ce.ToString(f);
|
|
M(i, c);
|
|
a += 1;
|
|
}
|
|
return i.join('');
|
|
},
|
|
};
|
|
if (String.raw && String.raw({ raw: { 0: 'x', 1: 'y', length: 2 } }) !== 'xy') {
|
|
ne(String, 'raw', _e.raw);
|
|
}
|
|
b(String, _e);
|
|
var ke = function repeat(e, t) {
|
|
if (t < 1) {
|
|
return '';
|
|
}
|
|
if (t % 2) {
|
|
return repeat(e, t - 1) + e;
|
|
}
|
|
var r = repeat(e, t / 2);
|
|
return r + r;
|
|
};
|
|
var Le = Infinity;
|
|
var Fe = {
|
|
repeat: function repeat(e) {
|
|
var t = ce.ToString(ce.RequireObjectCoercible(this));
|
|
var r = ce.ToInteger(e);
|
|
if (r < 0 || r >= Le) {
|
|
throw new RangeError(
|
|
'repeat count must be less than infinity and not overflow maximum string size'
|
|
);
|
|
}
|
|
return ke(t, r);
|
|
},
|
|
startsWith: function startsWith(e) {
|
|
var t = ce.ToString(ce.RequireObjectCoercible(this));
|
|
if (ce.IsRegExp(e)) {
|
|
throw new TypeError('Cannot call method "startsWith" with a regex');
|
|
}
|
|
var r = ce.ToString(e);
|
|
var n;
|
|
if (arguments.length > 1) {
|
|
n = arguments[1];
|
|
}
|
|
var o = A(ce.ToInteger(n), 0);
|
|
return C(t, o, o + r.length) === r;
|
|
},
|
|
endsWith: function endsWith(e) {
|
|
var t = ce.ToString(ce.RequireObjectCoercible(this));
|
|
if (ce.IsRegExp(e)) {
|
|
throw new TypeError('Cannot call method "endsWith" with a regex');
|
|
}
|
|
var r = ce.ToString(e);
|
|
var n = t.length;
|
|
var o;
|
|
if (arguments.length > 1) {
|
|
o = arguments[1];
|
|
}
|
|
var i = typeof o === 'undefined' ? n : ce.ToInteger(o);
|
|
var a = R(A(i, 0), n);
|
|
return C(t, a - r.length, a) === r;
|
|
},
|
|
includes: function includes(e) {
|
|
if (ce.IsRegExp(e)) {
|
|
throw new TypeError('"includes" does not accept a RegExp');
|
|
}
|
|
var t = ce.ToString(e);
|
|
var r;
|
|
if (arguments.length > 1) {
|
|
r = arguments[1];
|
|
}
|
|
return I(this, t, r) !== -1;
|
|
},
|
|
codePointAt: function codePointAt(e) {
|
|
var t = ce.ToString(ce.RequireObjectCoercible(this));
|
|
var r = ce.ToInteger(e);
|
|
var n = t.length;
|
|
if (r >= 0 && r < n) {
|
|
var o = t.charCodeAt(r);
|
|
var i = r + 1 === n;
|
|
if (o < 55296 || o > 56319 || i) {
|
|
return o;
|
|
}
|
|
var a = t.charCodeAt(r + 1);
|
|
if (a < 56320 || a > 57343) {
|
|
return o;
|
|
}
|
|
return (o - 55296) * 1024 + (a - 56320) + 65536;
|
|
}
|
|
},
|
|
};
|
|
if (String.prototype.includes && 'a'.includes('a', Infinity) !== false) {
|
|
ne(String.prototype, 'includes', Fe.includes);
|
|
}
|
|
if (String.prototype.startsWith && String.prototype.endsWith) {
|
|
var De = i(function () {
|
|
return '/a/'.startsWith(/a/);
|
|
});
|
|
var ze = a(function () {
|
|
return 'abc'.startsWith('a', Infinity) === false;
|
|
});
|
|
if (!De || !ze) {
|
|
ne(String.prototype, 'startsWith', Fe.startsWith);
|
|
ne(String.prototype, 'endsWith', Fe.endsWith);
|
|
}
|
|
}
|
|
if (oe) {
|
|
var qe = a(function () {
|
|
var e = /a/;
|
|
e[$.match] = false;
|
|
return '/a/'.startsWith(e);
|
|
});
|
|
if (!qe) {
|
|
ne(String.prototype, 'startsWith', Fe.startsWith);
|
|
}
|
|
var We = a(function () {
|
|
var e = /a/;
|
|
e[$.match] = false;
|
|
return '/a/'.endsWith(e);
|
|
});
|
|
if (!We) {
|
|
ne(String.prototype, 'endsWith', Fe.endsWith);
|
|
}
|
|
var Ge = a(function () {
|
|
var e = /a/;
|
|
e[$.match] = false;
|
|
return '/a/'.includes(e);
|
|
});
|
|
if (!Ge) {
|
|
ne(String.prototype, 'includes', Fe.includes);
|
|
}
|
|
}
|
|
b(String.prototype, Fe);
|
|
var He = [
|
|
'\t\n\x0B\f\r \xa0\u1680\u180e\u2000\u2001\u2002\u2003',
|
|
'\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028',
|
|
'\u2029\ufeff',
|
|
].join('');
|
|
var Ve = new RegExp('(^[' + He + ']+)|([' + He + ']+$)', 'g');
|
|
var Be = function trim() {
|
|
return ce.ToString(ce.RequireObjectCoercible(this)).replace(Ve, '');
|
|
};
|
|
var Ue = ['\x85', '\u200b', '\ufffe'].join('');
|
|
var $e = new RegExp('[' + Ue + ']', 'g');
|
|
var Je = /^[-+]0x[0-9a-f]+$/i;
|
|
var Xe = Ue.trim().length !== Ue.length;
|
|
h(String.prototype, 'trim', Be, Xe);
|
|
var Ke = function (e) {
|
|
return { value: e, done: arguments.length === 0 };
|
|
};
|
|
var Ze = function (e) {
|
|
ce.RequireObjectCoercible(e);
|
|
this._s = ce.ToString(e);
|
|
this._i = 0;
|
|
};
|
|
Ze.prototype.next = function () {
|
|
var e = this._s;
|
|
var t = this._i;
|
|
if (typeof e === 'undefined' || t >= e.length) {
|
|
this._s = void 0;
|
|
return Ke();
|
|
}
|
|
var r = e.charCodeAt(t);
|
|
var n, o;
|
|
if (r < 55296 || r > 56319 || t + 1 === e.length) {
|
|
o = 1;
|
|
} else {
|
|
n = e.charCodeAt(t + 1);
|
|
o = n < 56320 || n > 57343 ? 1 : 2;
|
|
}
|
|
this._i = t + o;
|
|
return Ke(e.substr(t, o));
|
|
};
|
|
Me(Ze.prototype);
|
|
Me(String.prototype, function () {
|
|
return new Ze(this);
|
|
});
|
|
var Ye = {
|
|
from: function from(e) {
|
|
var r = this;
|
|
var n;
|
|
if (arguments.length > 1) {
|
|
n = arguments[1];
|
|
}
|
|
var o, i;
|
|
if (typeof n === 'undefined') {
|
|
o = false;
|
|
} else {
|
|
if (!ce.IsCallable(n)) {
|
|
throw new TypeError('Array.from: when provided, the second argument must be a function');
|
|
}
|
|
if (arguments.length > 2) {
|
|
i = arguments[2];
|
|
}
|
|
o = true;
|
|
}
|
|
var a = typeof (te(e) || ce.GetMethod(e, ie)) !== 'undefined';
|
|
var u, f, s;
|
|
if (a) {
|
|
f = ce.IsConstructor(r) ? Object(new r()) : [];
|
|
var c = ce.GetIterator(e);
|
|
var l, p;
|
|
s = 0;
|
|
while (true) {
|
|
l = ce.IteratorStep(c);
|
|
if (l === false) {
|
|
break;
|
|
}
|
|
p = l.value;
|
|
try {
|
|
if (o) {
|
|
p = typeof i === 'undefined' ? n(p, s) : t(n, i, p, s);
|
|
}
|
|
f[s] = p;
|
|
} catch (v) {
|
|
ce.IteratorClose(c, true);
|
|
throw v;
|
|
}
|
|
s += 1;
|
|
}
|
|
u = s;
|
|
} else {
|
|
var y = ce.ToObject(e);
|
|
u = ce.ToLength(y.length);
|
|
f = ce.IsConstructor(r) ? Object(new r(u)) : new Array(u);
|
|
var h;
|
|
for (s = 0; s < u; ++s) {
|
|
h = y[s];
|
|
if (o) {
|
|
h = typeof i === 'undefined' ? n(h, s) : t(n, i, h, s);
|
|
}
|
|
Ne(f, s, h);
|
|
}
|
|
}
|
|
f.length = u;
|
|
return f;
|
|
},
|
|
of: function of() {
|
|
var e = arguments.length;
|
|
var t = this;
|
|
var n = r(t) || !ce.IsCallable(t) ? new Array(e) : ce.Construct(t, [e]);
|
|
for (var o = 0; o < e; ++o) {
|
|
Ne(n, o, arguments[o]);
|
|
}
|
|
n.length = e;
|
|
return n;
|
|
},
|
|
};
|
|
b(Array, Ye);
|
|
Ce(Array);
|
|
q = function (e, t) {
|
|
this.i = 0;
|
|
this.array = e;
|
|
this.kind = t;
|
|
};
|
|
b(q.prototype, {
|
|
next: function () {
|
|
var e = this.i;
|
|
var t = this.array;
|
|
if (!(this instanceof q)) {
|
|
throw new TypeError('Not an ArrayIterator');
|
|
}
|
|
if (typeof t !== 'undefined') {
|
|
var r = ce.ToLength(t.length);
|
|
for (; e < r; e++) {
|
|
var n = this.kind;
|
|
var o;
|
|
if (n === 'key') {
|
|
o = e;
|
|
} else if (n === 'value') {
|
|
o = t[e];
|
|
} else if (n === 'entry') {
|
|
o = [e, t[e]];
|
|
}
|
|
this.i = e + 1;
|
|
return Ke(o);
|
|
}
|
|
}
|
|
this.array = void 0;
|
|
return Ke();
|
|
},
|
|
});
|
|
Me(q.prototype);
|
|
var Qe =
|
|
Array.of === Ye.of ||
|
|
(function () {
|
|
var e = function Foo(e) {
|
|
this.length = e;
|
|
};
|
|
e.prototype = [];
|
|
var t = Array.of.apply(e, [1, 2]);
|
|
return t instanceof e && t.length === 2;
|
|
})();
|
|
if (!Qe) {
|
|
ne(Array, 'of', Ye.of);
|
|
}
|
|
var et = {
|
|
copyWithin: function copyWithin(e, t) {
|
|
var r = ce.ToObject(this);
|
|
var n = ce.ToLength(r.length);
|
|
var o = ce.ToInteger(e);
|
|
var i = ce.ToInteger(t);
|
|
var a = o < 0 ? A(n + o, 0) : R(o, n);
|
|
var u = i < 0 ? A(n + i, 0) : R(i, n);
|
|
var f;
|
|
if (arguments.length > 2) {
|
|
f = arguments[2];
|
|
}
|
|
var s = typeof f === 'undefined' ? n : ce.ToInteger(f);
|
|
var c = s < 0 ? A(n + s, 0) : R(s, n);
|
|
var l = R(c - u, n - a);
|
|
var p = 1;
|
|
if (u < a && a < u + l) {
|
|
p = -1;
|
|
u += l - 1;
|
|
a += l - 1;
|
|
}
|
|
while (l > 0) {
|
|
if (u in r) {
|
|
r[a] = r[u];
|
|
} else {
|
|
delete r[a];
|
|
}
|
|
u += p;
|
|
a += p;
|
|
l -= 1;
|
|
}
|
|
return r;
|
|
},
|
|
fill: function fill(e) {
|
|
var t;
|
|
if (arguments.length > 1) {
|
|
t = arguments[1];
|
|
}
|
|
var r;
|
|
if (arguments.length > 2) {
|
|
r = arguments[2];
|
|
}
|
|
var n = ce.ToObject(this);
|
|
var o = ce.ToLength(n.length);
|
|
t = ce.ToInteger(typeof t === 'undefined' ? 0 : t);
|
|
r = ce.ToInteger(typeof r === 'undefined' ? o : r);
|
|
var i = t < 0 ? A(o + t, 0) : R(t, o);
|
|
var a = r < 0 ? o + r : r;
|
|
for (var u = i; u < o && u < a; ++u) {
|
|
n[u] = e;
|
|
}
|
|
return n;
|
|
},
|
|
find: function find(e) {
|
|
var r = ce.ToObject(this);
|
|
var n = ce.ToLength(r.length);
|
|
if (!ce.IsCallable(e)) {
|
|
throw new TypeError('Array#find: predicate must be a function');
|
|
}
|
|
var o = arguments.length > 1 ? arguments[1] : null;
|
|
for (var i = 0, a; i < n; i++) {
|
|
a = r[i];
|
|
if (o) {
|
|
if (t(e, o, a, i, r)) {
|
|
return a;
|
|
}
|
|
} else if (e(a, i, r)) {
|
|
return a;
|
|
}
|
|
}
|
|
},
|
|
findIndex: function findIndex(e) {
|
|
var r = ce.ToObject(this);
|
|
var n = ce.ToLength(r.length);
|
|
if (!ce.IsCallable(e)) {
|
|
throw new TypeError('Array#findIndex: predicate must be a function');
|
|
}
|
|
var o = arguments.length > 1 ? arguments[1] : null;
|
|
for (var i = 0; i < n; i++) {
|
|
if (o) {
|
|
if (t(e, o, r[i], i, r)) {
|
|
return i;
|
|
}
|
|
} else if (e(r[i], i, r)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
},
|
|
keys: function keys() {
|
|
return new q(this, 'key');
|
|
},
|
|
values: function values() {
|
|
return new q(this, 'value');
|
|
},
|
|
entries: function entries() {
|
|
return new q(this, 'entry');
|
|
},
|
|
};
|
|
if (Array.prototype.keys && !ce.IsCallable([1].keys().next)) {
|
|
delete Array.prototype.keys;
|
|
}
|
|
if (Array.prototype.entries && !ce.IsCallable([1].entries().next)) {
|
|
delete Array.prototype.entries;
|
|
}
|
|
if (
|
|
Array.prototype.keys &&
|
|
Array.prototype.entries &&
|
|
!Array.prototype.values &&
|
|
Array.prototype[ie]
|
|
) {
|
|
b(Array.prototype, { values: Array.prototype[ie] });
|
|
if (re.symbol($.unscopables)) {
|
|
Array.prototype[$.unscopables].values = true;
|
|
}
|
|
}
|
|
if (c && Array.prototype.values && Array.prototype.values.name !== 'values') {
|
|
var tt = Array.prototype.values;
|
|
ne(Array.prototype, 'values', function values() {
|
|
return ce.Call(tt, this, arguments);
|
|
});
|
|
h(Array.prototype, ie, Array.prototype.values, true);
|
|
}
|
|
b(Array.prototype, et);
|
|
if (1 / [true].indexOf(true, -0) < 0) {
|
|
h(
|
|
Array.prototype,
|
|
'indexOf',
|
|
function indexOf(e) {
|
|
var t = E(this, arguments);
|
|
if (t === 0 && 1 / t < 0) {
|
|
return 0;
|
|
}
|
|
return t;
|
|
},
|
|
true
|
|
);
|
|
}
|
|
Me(Array.prototype, function () {
|
|
return this.values();
|
|
});
|
|
if (Object.getPrototypeOf) {
|
|
Me(Object.getPrototypeOf([].values()));
|
|
}
|
|
var rt = (function () {
|
|
return a(function () {
|
|
return Array.from({ length: -1 }).length === 0;
|
|
});
|
|
})();
|
|
var nt = (function () {
|
|
var e = Array.from([0].entries());
|
|
return e.length === 1 && r(e[0]) && e[0][0] === 0 && e[0][1] === 0;
|
|
})();
|
|
if (!rt || !nt) {
|
|
ne(Array, 'from', Ye.from);
|
|
}
|
|
var ot = (function () {
|
|
return a(function () {
|
|
return Array.from([0], void 0);
|
|
});
|
|
})();
|
|
if (!ot) {
|
|
var it = Array.from;
|
|
ne(Array, 'from', function from(e) {
|
|
if (arguments.length > 1 && typeof arguments[1] !== 'undefined') {
|
|
return ce.Call(it, this, arguments);
|
|
} else {
|
|
return t(it, this, e);
|
|
}
|
|
});
|
|
}
|
|
var at = -(Math.pow(2, 32) - 1);
|
|
var ut = function (e, r) {
|
|
var n = { length: at };
|
|
n[r ? (n.length >>> 0) - 1 : 0] = true;
|
|
return a(function () {
|
|
t(
|
|
e,
|
|
n,
|
|
function () {
|
|
throw new RangeError('should not reach here');
|
|
},
|
|
[]
|
|
);
|
|
return true;
|
|
});
|
|
};
|
|
if (!ut(Array.prototype.forEach)) {
|
|
var ft = Array.prototype.forEach;
|
|
ne(
|
|
Array.prototype,
|
|
'forEach',
|
|
function forEach(e) {
|
|
return ce.Call(ft, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.map)) {
|
|
var st = Array.prototype.map;
|
|
ne(
|
|
Array.prototype,
|
|
'map',
|
|
function map(e) {
|
|
return ce.Call(st, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.filter)) {
|
|
var ct = Array.prototype.filter;
|
|
ne(
|
|
Array.prototype,
|
|
'filter',
|
|
function filter(e) {
|
|
return ce.Call(ct, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.some)) {
|
|
var lt = Array.prototype.some;
|
|
ne(
|
|
Array.prototype,
|
|
'some',
|
|
function some(e) {
|
|
return ce.Call(lt, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.every)) {
|
|
var pt = Array.prototype.every;
|
|
ne(
|
|
Array.prototype,
|
|
'every',
|
|
function every(e) {
|
|
return ce.Call(pt, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.reduce)) {
|
|
var vt = Array.prototype.reduce;
|
|
ne(
|
|
Array.prototype,
|
|
'reduce',
|
|
function reduce(e) {
|
|
return ce.Call(vt, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
if (!ut(Array.prototype.reduceRight, true)) {
|
|
var yt = Array.prototype.reduceRight;
|
|
ne(
|
|
Array.prototype,
|
|
'reduceRight',
|
|
function reduceRight(e) {
|
|
return ce.Call(yt, this.length >= 0 ? this : [], arguments);
|
|
},
|
|
true
|
|
);
|
|
}
|
|
var ht = Number('0o10') !== 8;
|
|
var bt = Number('0b10') !== 2;
|
|
var gt = y(Ue, function (e) {
|
|
return Number(e + 0 + e) === 0;
|
|
});
|
|
if (ht || bt || gt) {
|
|
var dt = Number;
|
|
var mt = /^0b[01]+$/i;
|
|
var Ot = /^0o[0-7]+$/i;
|
|
var wt = mt.test.bind(mt);
|
|
var jt = Ot.test.bind(Ot);
|
|
var St = function (e) {
|
|
var t;
|
|
if (typeof e.valueOf === 'function') {
|
|
t = e.valueOf();
|
|
if (re.primitive(t)) {
|
|
return t;
|
|
}
|
|
}
|
|
if (typeof e.toString === 'function') {
|
|
t = e.toString();
|
|
if (re.primitive(t)) {
|
|
return t;
|
|
}
|
|
}
|
|
throw new TypeError('No default value');
|
|
};
|
|
var Tt = $e.test.bind($e);
|
|
var It = Je.test.bind(Je);
|
|
var Et = (function () {
|
|
var e = function Number(t) {
|
|
var r;
|
|
if (arguments.length > 0) {
|
|
r = re.primitive(t) ? t : St(t, 'number');
|
|
} else {
|
|
r = 0;
|
|
}
|
|
if (typeof r === 'string') {
|
|
r = ce.Call(Be, r);
|
|
if (wt(r)) {
|
|
r = parseInt(C(r, 2), 2);
|
|
} else if (jt(r)) {
|
|
r = parseInt(C(r, 2), 8);
|
|
} else if (Tt(r) || It(r)) {
|
|
r = NaN;
|
|
}
|
|
}
|
|
var n = this;
|
|
var o = a(function () {
|
|
dt.prototype.valueOf.call(n);
|
|
return true;
|
|
});
|
|
if (n instanceof e && !o) {
|
|
return new dt(r);
|
|
}
|
|
return dt(r);
|
|
};
|
|
return e;
|
|
})();
|
|
Ee(dt, Et, {});
|
|
b(Et, {
|
|
NaN: dt.NaN,
|
|
MAX_VALUE: dt.MAX_VALUE,
|
|
MIN_VALUE: dt.MIN_VALUE,
|
|
NEGATIVE_INFINITY: dt.NEGATIVE_INFINITY,
|
|
POSITIVE_INFINITY: dt.POSITIVE_INFINITY,
|
|
});
|
|
Number = Et;
|
|
m.redefine(S, 'Number', Et);
|
|
}
|
|
var Pt = Math.pow(2, 53) - 1;
|
|
b(Number, {
|
|
MAX_SAFE_INTEGER: Pt,
|
|
MIN_SAFE_INTEGER: -Pt,
|
|
EPSILON: 2.220446049250313e-16,
|
|
parseInt: S.parseInt,
|
|
parseFloat: S.parseFloat,
|
|
isFinite: K,
|
|
isInteger: function isInteger(e) {
|
|
return K(e) && ce.ToInteger(e) === e;
|
|
},
|
|
isSafeInteger: function isSafeInteger(e) {
|
|
return Number.isInteger(e) && k(e) <= Number.MAX_SAFE_INTEGER;
|
|
},
|
|
isNaN: X,
|
|
});
|
|
h(Number, 'parseInt', S.parseInt, Number.parseInt !== S.parseInt);
|
|
if (
|
|
[, 1].find(function () {
|
|
return true;
|
|
}) === 1
|
|
) {
|
|
ne(Array.prototype, 'find', et.find);
|
|
}
|
|
if (
|
|
[, 1].findIndex(function () {
|
|
return true;
|
|
}) !== 0
|
|
) {
|
|
ne(Array.prototype, 'findIndex', et.findIndex);
|
|
}
|
|
var Ct = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable);
|
|
var Mt = function ensureEnumerable(e, t) {
|
|
if (s && Ct(e, t)) {
|
|
Object.defineProperty(e, t, { enumerable: false });
|
|
}
|
|
};
|
|
var xt = function sliceArgs() {
|
|
var e = Number(this);
|
|
var t = arguments.length;
|
|
var r = t - e;
|
|
var n = new Array(r < 0 ? 0 : r);
|
|
for (var o = e; o < t; ++o) {
|
|
n[o - e] = arguments[o];
|
|
}
|
|
return n;
|
|
};
|
|
var Nt = function assignTo(e) {
|
|
return function assignToSource(t, r) {
|
|
t[r] = e[r];
|
|
return t;
|
|
};
|
|
};
|
|
var At = function (e, t) {
|
|
var r = n(Object(t));
|
|
var o;
|
|
if (ce.IsCallable(Object.getOwnPropertySymbols)) {
|
|
o = v(Object.getOwnPropertySymbols(Object(t)), Ct(t));
|
|
}
|
|
return p(P(r, o || []), Nt(t), e);
|
|
};
|
|
var Rt = {
|
|
assign: function (e, t) {
|
|
var r = ce.ToObject(e, 'Cannot convert undefined or null to object');
|
|
return p(ce.Call(xt, 1, arguments), At, r);
|
|
},
|
|
is: function is(e, t) {
|
|
return ce.SameValue(e, t);
|
|
},
|
|
};
|
|
var _t =
|
|
Object.assign &&
|
|
Object.preventExtensions &&
|
|
(function () {
|
|
var e = Object.preventExtensions({ 1: 2 });
|
|
try {
|
|
Object.assign(e, 'xy');
|
|
} catch (t) {
|
|
return e[1] === 'y';
|
|
}
|
|
})();
|
|
if (_t) {
|
|
ne(Object, 'assign', Rt.assign);
|
|
}
|
|
b(Object, Rt);
|
|
if (s) {
|
|
var kt = {
|
|
setPrototypeOf: (function (e, r) {
|
|
var n;
|
|
var o = function (e, t) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
throw new TypeError('cannot set prototype on a non-object');
|
|
}
|
|
if (!(t === null || ce.TypeIsObject(t))) {
|
|
throw new TypeError('can only set prototype to an object or null' + t);
|
|
}
|
|
};
|
|
var i = function (e, r) {
|
|
o(e, r);
|
|
t(n, e, r);
|
|
return e;
|
|
};
|
|
try {
|
|
n = e.getOwnPropertyDescriptor(e.prototype, r).set;
|
|
t(n, {}, null);
|
|
} catch (a) {
|
|
if (e.prototype !== {}[r]) {
|
|
return;
|
|
}
|
|
n = function (e) {
|
|
this[r] = e;
|
|
};
|
|
i.polyfill = i(i({}, null), e.prototype) instanceof e;
|
|
}
|
|
return i;
|
|
})(Object, '__proto__'),
|
|
};
|
|
b(Object, kt);
|
|
}
|
|
if (
|
|
Object.setPrototypeOf &&
|
|
Object.getPrototypeOf &&
|
|
Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null &&
|
|
Object.getPrototypeOf(Object.create(null)) === null
|
|
) {
|
|
(function () {
|
|
var e = Object.create(null);
|
|
var t = Object.getPrototypeOf;
|
|
var r = Object.setPrototypeOf;
|
|
Object.getPrototypeOf = function (r) {
|
|
var n = t(r);
|
|
return n === e ? null : n;
|
|
};
|
|
Object.setPrototypeOf = function (t, n) {
|
|
var o = n === null ? e : n;
|
|
return r(t, o);
|
|
};
|
|
Object.setPrototypeOf.polyfill = false;
|
|
})();
|
|
}
|
|
var Lt = !i(function () {
|
|
return Object.keys('foo');
|
|
});
|
|
if (!Lt) {
|
|
var Ft = Object.keys;
|
|
ne(Object, 'keys', function keys(e) {
|
|
return Ft(ce.ToObject(e));
|
|
});
|
|
n = Object.keys;
|
|
}
|
|
var Dt = i(function () {
|
|
return Object.keys(/a/g);
|
|
});
|
|
if (Dt) {
|
|
var zt = Object.keys;
|
|
ne(Object, 'keys', function keys(e) {
|
|
if (re.regex(e)) {
|
|
var t = [];
|
|
for (var r in e) {
|
|
if (z(e, r)) {
|
|
M(t, r);
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
return zt(e);
|
|
});
|
|
n = Object.keys;
|
|
}
|
|
if (Object.getOwnPropertyNames) {
|
|
var qt = !i(function () {
|
|
return Object.getOwnPropertyNames('foo');
|
|
});
|
|
if (!qt) {
|
|
var Wt = typeof window === 'object' ? Object.getOwnPropertyNames(window) : [];
|
|
var Gt = Object.getOwnPropertyNames;
|
|
ne(Object, 'getOwnPropertyNames', function getOwnPropertyNames(e) {
|
|
var t = ce.ToObject(e);
|
|
if (g(t) === '[object Window]') {
|
|
try {
|
|
return Gt(t);
|
|
} catch (r) {
|
|
return P([], Wt);
|
|
}
|
|
}
|
|
return Gt(t);
|
|
});
|
|
}
|
|
}
|
|
if (Object.getOwnPropertyDescriptor) {
|
|
var Ht = !i(function () {
|
|
return Object.getOwnPropertyDescriptor('foo', 'bar');
|
|
});
|
|
if (!Ht) {
|
|
var Vt = Object.getOwnPropertyDescriptor;
|
|
ne(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(e, t) {
|
|
return Vt(ce.ToObject(e), t);
|
|
});
|
|
}
|
|
}
|
|
if (Object.seal) {
|
|
var Bt = !i(function () {
|
|
return Object.seal('foo');
|
|
});
|
|
if (!Bt) {
|
|
var Ut = Object.seal;
|
|
ne(Object, 'seal', function seal(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return e;
|
|
}
|
|
return Ut(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.isSealed) {
|
|
var $t = !i(function () {
|
|
return Object.isSealed('foo');
|
|
});
|
|
if (!$t) {
|
|
var Jt = Object.isSealed;
|
|
ne(Object, 'isSealed', function isSealed(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return true;
|
|
}
|
|
return Jt(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.freeze) {
|
|
var Xt = !i(function () {
|
|
return Object.freeze('foo');
|
|
});
|
|
if (!Xt) {
|
|
var Kt = Object.freeze;
|
|
ne(Object, 'freeze', function freeze(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return e;
|
|
}
|
|
return Kt(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.isFrozen) {
|
|
var Zt = !i(function () {
|
|
return Object.isFrozen('foo');
|
|
});
|
|
if (!Zt) {
|
|
var Yt = Object.isFrozen;
|
|
ne(Object, 'isFrozen', function isFrozen(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return true;
|
|
}
|
|
return Yt(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.preventExtensions) {
|
|
var Qt = !i(function () {
|
|
return Object.preventExtensions('foo');
|
|
});
|
|
if (!Qt) {
|
|
var er = Object.preventExtensions;
|
|
ne(Object, 'preventExtensions', function preventExtensions(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return e;
|
|
}
|
|
return er(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.isExtensible) {
|
|
var tr = !i(function () {
|
|
return Object.isExtensible('foo');
|
|
});
|
|
if (!tr) {
|
|
var rr = Object.isExtensible;
|
|
ne(Object, 'isExtensible', function isExtensible(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return false;
|
|
}
|
|
return rr(e);
|
|
});
|
|
}
|
|
}
|
|
if (Object.getPrototypeOf) {
|
|
var nr = !i(function () {
|
|
return Object.getPrototypeOf('foo');
|
|
});
|
|
if (!nr) {
|
|
var or = Object.getPrototypeOf;
|
|
ne(Object, 'getPrototypeOf', function getPrototypeOf(e) {
|
|
return or(ce.ToObject(e));
|
|
});
|
|
}
|
|
}
|
|
var ir =
|
|
s &&
|
|
(function () {
|
|
var e = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags');
|
|
return e && ce.IsCallable(e.get);
|
|
})();
|
|
if (s && !ir) {
|
|
var ar = function flags() {
|
|
if (!ce.TypeIsObject(this)) {
|
|
throw new TypeError('Method called on incompatible type: must be an object.');
|
|
}
|
|
var e = '';
|
|
if (this.global) {
|
|
e += 'g';
|
|
}
|
|
if (this.ignoreCase) {
|
|
e += 'i';
|
|
}
|
|
if (this.multiline) {
|
|
e += 'm';
|
|
}
|
|
if (this.unicode) {
|
|
e += 'u';
|
|
}
|
|
if (this.sticky) {
|
|
e += 'y';
|
|
}
|
|
return e;
|
|
};
|
|
m.getter(RegExp.prototype, 'flags', ar);
|
|
}
|
|
var ur =
|
|
s &&
|
|
a(function () {
|
|
return String(new RegExp(/a/g, 'i')) === '/a/i';
|
|
});
|
|
var fr =
|
|
oe &&
|
|
s &&
|
|
(function () {
|
|
var e = /./;
|
|
e[$.match] = false;
|
|
return RegExp(e) === e;
|
|
})();
|
|
var sr = a(function () {
|
|
return RegExp.prototype.toString.call({ source: 'abc' }) === '/abc/';
|
|
});
|
|
var cr =
|
|
sr &&
|
|
a(function () {
|
|
return RegExp.prototype.toString.call({ source: 'a', flags: 'b' }) === '/a/b';
|
|
});
|
|
if (!sr || !cr) {
|
|
var lr = RegExp.prototype.toString;
|
|
h(
|
|
RegExp.prototype,
|
|
'toString',
|
|
function toString() {
|
|
var e = ce.RequireObjectCoercible(this);
|
|
if (re.regex(e)) {
|
|
return t(lr, e);
|
|
}
|
|
var r = ue(e.source);
|
|
var n = ue(e.flags);
|
|
return '/' + r + '/' + n;
|
|
},
|
|
true
|
|
);
|
|
m.preserveToString(RegExp.prototype.toString, lr);
|
|
}
|
|
if (s && (!ur || fr)) {
|
|
var pr = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get;
|
|
var vr = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') || {};
|
|
var yr = function () {
|
|
return this.source;
|
|
};
|
|
var hr = ce.IsCallable(vr.get) ? vr.get : yr;
|
|
var br = RegExp;
|
|
var gr = (function () {
|
|
return function RegExp(e, t) {
|
|
var r = ce.IsRegExp(e);
|
|
var n = this instanceof RegExp;
|
|
if (!n && r && typeof t === 'undefined' && e.constructor === RegExp) {
|
|
return e;
|
|
}
|
|
var o = e;
|
|
var i = t;
|
|
if (re.regex(e)) {
|
|
o = ce.Call(hr, e);
|
|
i = typeof t === 'undefined' ? ce.Call(pr, e) : t;
|
|
return new RegExp(o, i);
|
|
} else if (r) {
|
|
o = e.source;
|
|
i = typeof t === 'undefined' ? e.flags : t;
|
|
}
|
|
return new br(e, t);
|
|
};
|
|
})();
|
|
Ee(br, gr, { $input: true });
|
|
RegExp = gr;
|
|
m.redefine(S, 'RegExp', gr);
|
|
}
|
|
if (s) {
|
|
var dr = {
|
|
input: '$_',
|
|
lastMatch: '$&',
|
|
lastParen: '$+',
|
|
leftContext: '$`',
|
|
rightContext: "$'",
|
|
};
|
|
l(n(dr), function (e) {
|
|
if (e in RegExp && !(dr[e] in RegExp)) {
|
|
m.getter(RegExp, dr[e], function get() {
|
|
return RegExp[e];
|
|
});
|
|
}
|
|
});
|
|
}
|
|
Ce(RegExp);
|
|
var mr = 1 / Number.EPSILON;
|
|
var Or = function roundTiesToEven(e) {
|
|
return e + mr - mr;
|
|
};
|
|
var wr = Math.pow(2, -23);
|
|
var jr = Math.pow(2, 127) * (2 - wr);
|
|
var Sr = Math.pow(2, -126);
|
|
var Tr = Math.E;
|
|
var Ir = Math.LOG2E;
|
|
var Er = Math.LOG10E;
|
|
var Pr = Number.prototype.clz;
|
|
delete Number.prototype.clz;
|
|
var Cr = {
|
|
acosh: function acosh(e) {
|
|
var t = Number(e);
|
|
if (X(t) || e < 1) {
|
|
return NaN;
|
|
}
|
|
if (t === 1) {
|
|
return 0;
|
|
}
|
|
if (t === Infinity) {
|
|
return t;
|
|
}
|
|
var r = 1 / (t * t);
|
|
if (t < 2) {
|
|
return Y(t - 1 + D(1 - r) * t);
|
|
}
|
|
var n = t / 2;
|
|
return Y(n + D(1 - r) * n - 1) + 1 / Ir;
|
|
},
|
|
asinh: function asinh(e) {
|
|
var t = Number(e);
|
|
if (t === 0 || !T(t)) {
|
|
return t;
|
|
}
|
|
var r = k(t);
|
|
var n = r * r;
|
|
var o = Z(t);
|
|
if (r < 1) {
|
|
return o * Y(r + n / (D(n + 1) + 1));
|
|
}
|
|
return o * (Y(r / 2 + (D(1 + 1 / n) * r) / 2 - 1) + 1 / Ir);
|
|
},
|
|
atanh: function atanh(e) {
|
|
var t = Number(e);
|
|
if (t === 0) {
|
|
return t;
|
|
}
|
|
if (t === -1) {
|
|
return -Infinity;
|
|
}
|
|
if (t === 1) {
|
|
return Infinity;
|
|
}
|
|
if (X(t) || t < -1 || t > 1) {
|
|
return NaN;
|
|
}
|
|
var r = k(t);
|
|
return (Z(t) * Y((2 * r) / (1 - r))) / 2;
|
|
},
|
|
cbrt: function cbrt(e) {
|
|
var t = Number(e);
|
|
if (t === 0) {
|
|
return t;
|
|
}
|
|
var r = t < 0;
|
|
var n;
|
|
if (r) {
|
|
t = -t;
|
|
}
|
|
if (t === Infinity) {
|
|
n = Infinity;
|
|
} else {
|
|
n = L(F(t) / 3);
|
|
n = (t / (n * n) + 2 * n) / 3;
|
|
}
|
|
return r ? -n : n;
|
|
},
|
|
clz32: function clz32(e) {
|
|
var t = Number(e);
|
|
var r = ce.ToUint32(t);
|
|
if (r === 0) {
|
|
return 32;
|
|
}
|
|
return Pr ? ce.Call(Pr, r) : 31 - _(F(r + 0.5) * Ir);
|
|
},
|
|
cosh: function cosh(e) {
|
|
var t = Number(e);
|
|
if (t === 0) {
|
|
return 1;
|
|
}
|
|
if (X(t)) {
|
|
return NaN;
|
|
}
|
|
if (!T(t)) {
|
|
return Infinity;
|
|
}
|
|
var r = L(k(t) - 1);
|
|
return (r + 1 / (r * Tr * Tr)) * (Tr / 2);
|
|
},
|
|
expm1: function expm1(e) {
|
|
var t = Number(e);
|
|
if (t === -Infinity) {
|
|
return -1;
|
|
}
|
|
if (!T(t) || t === 0) {
|
|
return t;
|
|
}
|
|
if (k(t) > 0.5) {
|
|
return L(t) - 1;
|
|
}
|
|
var r = t;
|
|
var n = 0;
|
|
var o = 1;
|
|
while (n + r !== n) {
|
|
n += r;
|
|
o += 1;
|
|
r *= t / o;
|
|
}
|
|
return n;
|
|
},
|
|
hypot: function hypot(e, t) {
|
|
var r = 0;
|
|
var n = 0;
|
|
for (var o = 0; o < arguments.length; ++o) {
|
|
var i = k(Number(arguments[o]));
|
|
if (n < i) {
|
|
r *= (n / i) * (n / i);
|
|
r += 1;
|
|
n = i;
|
|
} else {
|
|
r += i > 0 ? (i / n) * (i / n) : i;
|
|
}
|
|
}
|
|
return n === Infinity ? Infinity : n * D(r);
|
|
},
|
|
log2: function log2(e) {
|
|
return F(e) * Ir;
|
|
},
|
|
log10: function log10(e) {
|
|
return F(e) * Er;
|
|
},
|
|
log1p: Y,
|
|
sign: Z,
|
|
sinh: function sinh(e) {
|
|
var t = Number(e);
|
|
if (!T(t) || t === 0) {
|
|
return t;
|
|
}
|
|
var r = k(t);
|
|
if (r < 1) {
|
|
var n = Math.expm1(r);
|
|
return (Z(t) * n * (1 + 1 / (n + 1))) / 2;
|
|
}
|
|
var o = L(r - 1);
|
|
return Z(t) * (o - 1 / (o * Tr * Tr)) * (Tr / 2);
|
|
},
|
|
tanh: function tanh(e) {
|
|
var t = Number(e);
|
|
if (X(t) || t === 0) {
|
|
return t;
|
|
}
|
|
if (t >= 20) {
|
|
return 1;
|
|
}
|
|
if (t <= -20) {
|
|
return -1;
|
|
}
|
|
return (Math.expm1(t) - Math.expm1(-t)) / (L(t) + L(-t));
|
|
},
|
|
trunc: function trunc(e) {
|
|
var t = Number(e);
|
|
return t < 0 ? -_(-t) : _(t);
|
|
},
|
|
imul: function imul(e, t) {
|
|
var r = ce.ToUint32(e);
|
|
var n = ce.ToUint32(t);
|
|
var o = (r >>> 16) & 65535;
|
|
var i = r & 65535;
|
|
var a = (n >>> 16) & 65535;
|
|
var u = n & 65535;
|
|
return (i * u + (((o * u + i * a) << 16) >>> 0)) | 0;
|
|
},
|
|
fround: function fround(e) {
|
|
var t = Number(e);
|
|
if (t === 0 || t === Infinity || t === -Infinity || X(t)) {
|
|
return t;
|
|
}
|
|
var r = Z(t);
|
|
var n = k(t);
|
|
if (n < Sr) {
|
|
return r * Or(n / Sr / wr) * Sr * wr;
|
|
}
|
|
var o = (1 + wr / Number.EPSILON) * n;
|
|
var i = o - (o - n);
|
|
if (i > jr || X(i)) {
|
|
return r * Infinity;
|
|
}
|
|
return r * i;
|
|
},
|
|
};
|
|
var Mr = function withinULPDistance(e, t, r) {
|
|
return k(1 - e / t) / Number.EPSILON < (r || 8);
|
|
};
|
|
b(Math, Cr);
|
|
h(Math, 'sinh', Cr.sinh, Math.sinh(710) === Infinity);
|
|
h(Math, 'cosh', Cr.cosh, Math.cosh(710) === Infinity);
|
|
h(Math, 'log1p', Cr.log1p, Math.log1p(-1e-17) !== -1e-17);
|
|
h(Math, 'asinh', Cr.asinh, Math.asinh(-1e7) !== -Math.asinh(1e7));
|
|
h(Math, 'asinh', Cr.asinh, Math.asinh(1e300) === Infinity);
|
|
h(Math, 'atanh', Cr.atanh, Math.atanh(1e-300) === 0);
|
|
h(Math, 'tanh', Cr.tanh, Math.tanh(-2e-17) !== -2e-17);
|
|
h(Math, 'acosh', Cr.acosh, Math.acosh(Number.MAX_VALUE) === Infinity);
|
|
h(Math, 'acosh', Cr.acosh, !Mr(Math.acosh(1 + Number.EPSILON), Math.sqrt(2 * Number.EPSILON)));
|
|
h(Math, 'cbrt', Cr.cbrt, !Mr(Math.cbrt(1e-300), 1e-100));
|
|
h(Math, 'sinh', Cr.sinh, Math.sinh(-2e-17) !== -2e-17);
|
|
var xr = Math.expm1(10);
|
|
h(Math, 'expm1', Cr.expm1, xr > 22025.465794806718 || xr < 22025.465794806718);
|
|
var Nr = Math.round;
|
|
var Ar =
|
|
Math.round(0.5 - Number.EPSILON / 4) === 0 && Math.round(-0.5 + Number.EPSILON / 3.99) === 1;
|
|
var Rr = mr + 1;
|
|
var _r = 2 * mr - 1;
|
|
var kr = [Rr, _r].every(function (e) {
|
|
return Math.round(e) === e;
|
|
});
|
|
h(
|
|
Math,
|
|
'round',
|
|
function round(e) {
|
|
var t = _(e);
|
|
var r = t === -1 ? -0 : t + 1;
|
|
return e - t < 0.5 ? t : r;
|
|
},
|
|
!Ar || !kr
|
|
);
|
|
m.preserveToString(Math.round, Nr);
|
|
var Lr = Math.imul;
|
|
if (Math.imul(4294967295, 5) !== -5) {
|
|
Math.imul = Cr.imul;
|
|
m.preserveToString(Math.imul, Lr);
|
|
}
|
|
if (Math.imul.length !== 2) {
|
|
ne(Math, 'imul', function imul(e, t) {
|
|
return ce.Call(Lr, Math, arguments);
|
|
});
|
|
}
|
|
var Fr = (function () {
|
|
var e = S.setTimeout;
|
|
if (typeof e !== 'function' && typeof e !== 'object') {
|
|
return;
|
|
}
|
|
ce.IsPromise = function (e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
return false;
|
|
}
|
|
if (typeof e._promise === 'undefined') {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
var r = function (e) {
|
|
if (!ce.IsConstructor(e)) {
|
|
throw new TypeError('Bad promise constructor');
|
|
}
|
|
var t = this;
|
|
var r = function (e, r) {
|
|
if (t.resolve !== void 0 || t.reject !== void 0) {
|
|
throw new TypeError('Bad Promise implementation!');
|
|
}
|
|
t.resolve = e;
|
|
t.reject = r;
|
|
};
|
|
t.resolve = void 0;
|
|
t.reject = void 0;
|
|
t.promise = new e(r);
|
|
if (!(ce.IsCallable(t.resolve) && ce.IsCallable(t.reject))) {
|
|
throw new TypeError('Bad promise constructor');
|
|
}
|
|
};
|
|
var n;
|
|
if (typeof window !== 'undefined' && ce.IsCallable(window.postMessage)) {
|
|
n = function () {
|
|
var e = [];
|
|
var t = 'zero-timeout-message';
|
|
var r = function (r) {
|
|
M(e, r);
|
|
window.postMessage(t, '*');
|
|
};
|
|
var n = function (r) {
|
|
if (r.source === window && r.data === t) {
|
|
r.stopPropagation();
|
|
if (e.length === 0) {
|
|
return;
|
|
}
|
|
var n = N(e);
|
|
n();
|
|
}
|
|
};
|
|
window.addEventListener('message', n, true);
|
|
return r;
|
|
};
|
|
}
|
|
var o = function () {
|
|
var e = S.Promise;
|
|
var t = e && e.resolve && e.resolve();
|
|
return (
|
|
t &&
|
|
function (e) {
|
|
return t.then(e);
|
|
}
|
|
);
|
|
};
|
|
var i = ce.IsCallable(S.setImmediate)
|
|
? S.setImmediate
|
|
: typeof process === 'object' && process.nextTick
|
|
? process.nextTick
|
|
: o() ||
|
|
(ce.IsCallable(n)
|
|
? n()
|
|
: function (t) {
|
|
e(t, 0);
|
|
});
|
|
var a = function (e) {
|
|
return e;
|
|
};
|
|
var u = function (e) {
|
|
throw e;
|
|
};
|
|
var f = 0;
|
|
var s = 1;
|
|
var c = 2;
|
|
var l = 0;
|
|
var p = 1;
|
|
var v = 2;
|
|
var y = {};
|
|
var h = function (e, t, r) {
|
|
i(function () {
|
|
g(e, t, r);
|
|
});
|
|
};
|
|
var g = function (e, t, r) {
|
|
var n, o;
|
|
if (t === y) {
|
|
return e(r);
|
|
}
|
|
try {
|
|
n = e(r);
|
|
o = t.resolve;
|
|
} catch (i) {
|
|
n = i;
|
|
o = t.reject;
|
|
}
|
|
o(n);
|
|
};
|
|
var d = function (e, t) {
|
|
var r = e._promise;
|
|
var n = r.reactionLength;
|
|
if (n > 0) {
|
|
h(r.fulfillReactionHandler0, r.reactionCapability0, t);
|
|
r.fulfillReactionHandler0 = void 0;
|
|
r.rejectReactions0 = void 0;
|
|
r.reactionCapability0 = void 0;
|
|
if (n > 1) {
|
|
for (var o = 1, i = 0; o < n; o++, i += 3) {
|
|
h(r[i + l], r[i + v], t);
|
|
e[i + l] = void 0;
|
|
e[i + p] = void 0;
|
|
e[i + v] = void 0;
|
|
}
|
|
}
|
|
}
|
|
r.result = t;
|
|
r.state = s;
|
|
r.reactionLength = 0;
|
|
};
|
|
var m = function (e, t) {
|
|
var r = e._promise;
|
|
var n = r.reactionLength;
|
|
if (n > 0) {
|
|
h(r.rejectReactionHandler0, r.reactionCapability0, t);
|
|
r.fulfillReactionHandler0 = void 0;
|
|
r.rejectReactions0 = void 0;
|
|
r.reactionCapability0 = void 0;
|
|
if (n > 1) {
|
|
for (var o = 1, i = 0; o < n; o++, i += 3) {
|
|
h(r[i + p], r[i + v], t);
|
|
e[i + l] = void 0;
|
|
e[i + p] = void 0;
|
|
e[i + v] = void 0;
|
|
}
|
|
}
|
|
}
|
|
r.result = t;
|
|
r.state = c;
|
|
r.reactionLength = 0;
|
|
};
|
|
var O = function (e) {
|
|
var t = false;
|
|
var r = function (r) {
|
|
var n;
|
|
if (t) {
|
|
return;
|
|
}
|
|
t = true;
|
|
if (r === e) {
|
|
return m(e, new TypeError('Self resolution'));
|
|
}
|
|
if (!ce.TypeIsObject(r)) {
|
|
return d(e, r);
|
|
}
|
|
try {
|
|
n = r.then;
|
|
} catch (o) {
|
|
return m(e, o);
|
|
}
|
|
if (!ce.IsCallable(n)) {
|
|
return d(e, r);
|
|
}
|
|
i(function () {
|
|
j(e, r, n);
|
|
});
|
|
};
|
|
var n = function (r) {
|
|
if (t) {
|
|
return;
|
|
}
|
|
t = true;
|
|
return m(e, r);
|
|
};
|
|
return { resolve: r, reject: n };
|
|
};
|
|
var w = function (e, r, n, o) {
|
|
if (e === I) {
|
|
t(e, r, n, o, y);
|
|
} else {
|
|
t(e, r, n, o);
|
|
}
|
|
};
|
|
var j = function (e, t, r) {
|
|
var n = O(e);
|
|
var o = n.resolve;
|
|
var i = n.reject;
|
|
try {
|
|
w(r, t, o, i);
|
|
} catch (a) {
|
|
i(a);
|
|
}
|
|
};
|
|
var T, I;
|
|
var E = (function () {
|
|
var e = function Promise(t) {
|
|
if (!(this instanceof e)) {
|
|
throw new TypeError('Constructor Promise requires "new"');
|
|
}
|
|
if (this && this._promise) {
|
|
throw new TypeError('Bad construction');
|
|
}
|
|
if (!ce.IsCallable(t)) {
|
|
throw new TypeError('not a valid resolver');
|
|
}
|
|
var r = Ae(this, e, T, {
|
|
_promise: {
|
|
result: void 0,
|
|
state: f,
|
|
reactionLength: 0,
|
|
fulfillReactionHandler0: void 0,
|
|
rejectReactionHandler0: void 0,
|
|
reactionCapability0: void 0,
|
|
},
|
|
});
|
|
var n = O(r);
|
|
var o = n.reject;
|
|
try {
|
|
t(n.resolve, o);
|
|
} catch (i) {
|
|
o(i);
|
|
}
|
|
return r;
|
|
};
|
|
return e;
|
|
})();
|
|
T = E.prototype;
|
|
var P = function (e, t, r, n) {
|
|
var o = false;
|
|
return function (i) {
|
|
if (o) {
|
|
return;
|
|
}
|
|
o = true;
|
|
t[e] = i;
|
|
if (--n.count === 0) {
|
|
var a = r.resolve;
|
|
a(t);
|
|
}
|
|
};
|
|
};
|
|
var C = function (e, t, r) {
|
|
var n = e.iterator;
|
|
var o = [];
|
|
var i = { count: 1 };
|
|
var a, u;
|
|
var f = 0;
|
|
while (true) {
|
|
try {
|
|
a = ce.IteratorStep(n);
|
|
if (a === false) {
|
|
e.done = true;
|
|
break;
|
|
}
|
|
u = a.value;
|
|
} catch (s) {
|
|
e.done = true;
|
|
throw s;
|
|
}
|
|
o[f] = void 0;
|
|
var c = t.resolve(u);
|
|
var l = P(f, o, r, i);
|
|
i.count += 1;
|
|
w(c.then, c, l, r.reject);
|
|
f += 1;
|
|
}
|
|
if (--i.count === 0) {
|
|
var p = r.resolve;
|
|
p(o);
|
|
}
|
|
return r.promise;
|
|
};
|
|
var x = function (e, t, r) {
|
|
var n = e.iterator;
|
|
var o, i, a;
|
|
while (true) {
|
|
try {
|
|
o = ce.IteratorStep(n);
|
|
if (o === false) {
|
|
e.done = true;
|
|
break;
|
|
}
|
|
i = o.value;
|
|
} catch (u) {
|
|
e.done = true;
|
|
throw u;
|
|
}
|
|
a = t.resolve(i);
|
|
w(a.then, a, r.resolve, r.reject);
|
|
}
|
|
return r.promise;
|
|
};
|
|
b(E, {
|
|
all: function all(e) {
|
|
var t = this;
|
|
if (!ce.TypeIsObject(t)) {
|
|
throw new TypeError('Promise is not object');
|
|
}
|
|
var n = new r(t);
|
|
var o, i;
|
|
try {
|
|
o = ce.GetIterator(e);
|
|
i = { iterator: o, done: false };
|
|
return C(i, t, n);
|
|
} catch (a) {
|
|
var u = a;
|
|
if (i && !i.done) {
|
|
try {
|
|
ce.IteratorClose(o, true);
|
|
} catch (f) {
|
|
u = f;
|
|
}
|
|
}
|
|
var s = n.reject;
|
|
s(u);
|
|
return n.promise;
|
|
}
|
|
},
|
|
race: function race(e) {
|
|
var t = this;
|
|
if (!ce.TypeIsObject(t)) {
|
|
throw new TypeError('Promise is not object');
|
|
}
|
|
var n = new r(t);
|
|
var o, i;
|
|
try {
|
|
o = ce.GetIterator(e);
|
|
i = { iterator: o, done: false };
|
|
return x(i, t, n);
|
|
} catch (a) {
|
|
var u = a;
|
|
if (i && !i.done) {
|
|
try {
|
|
ce.IteratorClose(o, true);
|
|
} catch (f) {
|
|
u = f;
|
|
}
|
|
}
|
|
var s = n.reject;
|
|
s(u);
|
|
return n.promise;
|
|
}
|
|
},
|
|
reject: function reject(e) {
|
|
var t = this;
|
|
if (!ce.TypeIsObject(t)) {
|
|
throw new TypeError('Bad promise constructor');
|
|
}
|
|
var n = new r(t);
|
|
var o = n.reject;
|
|
o(e);
|
|
return n.promise;
|
|
},
|
|
resolve: function resolve(e) {
|
|
var t = this;
|
|
if (!ce.TypeIsObject(t)) {
|
|
throw new TypeError('Bad promise constructor');
|
|
}
|
|
if (ce.IsPromise(e)) {
|
|
var n = e.constructor;
|
|
if (n === t) {
|
|
return e;
|
|
}
|
|
}
|
|
var o = new r(t);
|
|
var i = o.resolve;
|
|
i(e);
|
|
return o.promise;
|
|
},
|
|
});
|
|
b(T, {
|
|
catch: function (e) {
|
|
return this.then(null, e);
|
|
},
|
|
then: function then(e, t) {
|
|
var n = this;
|
|
if (!ce.IsPromise(n)) {
|
|
throw new TypeError('not a promise');
|
|
}
|
|
var o = ce.SpeciesConstructor(n, E);
|
|
var i;
|
|
var b = arguments.length > 2 && arguments[2] === y;
|
|
if (b && o === E) {
|
|
i = y;
|
|
} else {
|
|
i = new r(o);
|
|
}
|
|
var g = ce.IsCallable(e) ? e : a;
|
|
var d = ce.IsCallable(t) ? t : u;
|
|
var m = n._promise;
|
|
var O;
|
|
if (m.state === f) {
|
|
if (m.reactionLength === 0) {
|
|
m.fulfillReactionHandler0 = g;
|
|
m.rejectReactionHandler0 = d;
|
|
m.reactionCapability0 = i;
|
|
} else {
|
|
var w = 3 * (m.reactionLength - 1);
|
|
m[w + l] = g;
|
|
m[w + p] = d;
|
|
m[w + v] = i;
|
|
}
|
|
m.reactionLength += 1;
|
|
} else if (m.state === s) {
|
|
O = m.result;
|
|
h(g, i, O);
|
|
} else if (m.state === c) {
|
|
O = m.result;
|
|
h(d, i, O);
|
|
} else {
|
|
throw new TypeError('unexpected Promise state');
|
|
}
|
|
return i.promise;
|
|
},
|
|
});
|
|
y = new r(E);
|
|
I = T.then;
|
|
return E;
|
|
})();
|
|
if (S.Promise) {
|
|
delete S.Promise.accept;
|
|
delete S.Promise.defer;
|
|
delete S.Promise.prototype.chain;
|
|
}
|
|
if (typeof Fr === 'function') {
|
|
b(S, { Promise: Fr });
|
|
var Dr = w(S.Promise, function (e) {
|
|
return e.resolve(42).then(function () {}) instanceof e;
|
|
});
|
|
var zr = !i(function () {
|
|
return S.Promise.reject(42).then(null, 5).then(null, W);
|
|
});
|
|
var qr = i(function () {
|
|
return S.Promise.call(3, W);
|
|
});
|
|
var Wr = (function (e) {
|
|
var t = e.resolve(5);
|
|
t.constructor = {};
|
|
var r = e.resolve(t);
|
|
try {
|
|
r.then(null, W).then(null, W);
|
|
} catch (n) {
|
|
return true;
|
|
}
|
|
return t === r;
|
|
})(S.Promise);
|
|
var Gr =
|
|
s &&
|
|
(function () {
|
|
var e = 0;
|
|
var t = Object.defineProperty({}, 'then', {
|
|
get: function () {
|
|
e += 1;
|
|
},
|
|
});
|
|
Promise.resolve(t);
|
|
return e === 1;
|
|
})();
|
|
var Hr = function BadResolverPromise(e) {
|
|
var t = new Promise(e);
|
|
e(3, function () {});
|
|
this.then = t.then;
|
|
this.constructor = BadResolverPromise;
|
|
};
|
|
Hr.prototype = Promise.prototype;
|
|
Hr.all = Promise.all;
|
|
var Vr = a(function () {
|
|
return !!Hr.all([1, 2]);
|
|
});
|
|
if (!Dr || !zr || !qr || Wr || !Gr || Vr) {
|
|
Promise = Fr;
|
|
ne(S, 'Promise', Fr);
|
|
}
|
|
if (Promise.all.length !== 1) {
|
|
var Br = Promise.all;
|
|
ne(Promise, 'all', function all(e) {
|
|
return ce.Call(Br, this, arguments);
|
|
});
|
|
}
|
|
if (Promise.race.length !== 1) {
|
|
var Ur = Promise.race;
|
|
ne(Promise, 'race', function race(e) {
|
|
return ce.Call(Ur, this, arguments);
|
|
});
|
|
}
|
|
if (Promise.resolve.length !== 1) {
|
|
var $r = Promise.resolve;
|
|
ne(Promise, 'resolve', function resolve(e) {
|
|
return ce.Call($r, this, arguments);
|
|
});
|
|
}
|
|
if (Promise.reject.length !== 1) {
|
|
var Jr = Promise.reject;
|
|
ne(Promise, 'reject', function reject(e) {
|
|
return ce.Call(Jr, this, arguments);
|
|
});
|
|
}
|
|
Mt(Promise, 'all');
|
|
Mt(Promise, 'race');
|
|
Mt(Promise, 'resolve');
|
|
Mt(Promise, 'reject');
|
|
Ce(Promise);
|
|
}
|
|
var Xr = function (e) {
|
|
var t = n(
|
|
p(
|
|
e,
|
|
function (e, t) {
|
|
e[t] = true;
|
|
return e;
|
|
},
|
|
{}
|
|
)
|
|
);
|
|
return e.join(':') === t.join(':');
|
|
};
|
|
var Kr = Xr(['z', 'a', 'bb']);
|
|
var Zr = Xr(['z', 1, 'a', '3', 2]);
|
|
if (s) {
|
|
var Yr = function fastkey(e, t) {
|
|
if (!t && !Kr) {
|
|
return null;
|
|
}
|
|
if (se(e)) {
|
|
return '^' + ce.ToString(e);
|
|
} else if (typeof e === 'string') {
|
|
return '$' + e;
|
|
} else if (typeof e === 'number') {
|
|
if (!Zr) {
|
|
return 'n' + e;
|
|
}
|
|
return e;
|
|
} else if (typeof e === 'boolean') {
|
|
return 'b' + e;
|
|
}
|
|
return null;
|
|
};
|
|
var Qr = function emptyObject() {
|
|
return Object.create ? Object.create(null) : {};
|
|
};
|
|
var en = function addIterableToMap(e, n, o) {
|
|
if (r(o) || re.string(o)) {
|
|
l(o, function (e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
throw new TypeError('Iterator value ' + e + ' is not an entry object');
|
|
}
|
|
n.set(e[0], e[1]);
|
|
});
|
|
} else if (o instanceof e) {
|
|
t(e.prototype.forEach, o, function (e, t) {
|
|
n.set(t, e);
|
|
});
|
|
} else {
|
|
var i, a;
|
|
if (!se(o)) {
|
|
a = n.set;
|
|
if (!ce.IsCallable(a)) {
|
|
throw new TypeError('bad map');
|
|
}
|
|
i = ce.GetIterator(o);
|
|
}
|
|
if (typeof i !== 'undefined') {
|
|
while (true) {
|
|
var u = ce.IteratorStep(i);
|
|
if (u === false) {
|
|
break;
|
|
}
|
|
var f = u.value;
|
|
try {
|
|
if (!ce.TypeIsObject(f)) {
|
|
throw new TypeError('Iterator value ' + f + ' is not an entry object');
|
|
}
|
|
t(a, n, f[0], f[1]);
|
|
} catch (s) {
|
|
ce.IteratorClose(i, true);
|
|
throw s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var tn = function addIterableToSet(e, n, o) {
|
|
if (r(o) || re.string(o)) {
|
|
l(o, function (e) {
|
|
n.add(e);
|
|
});
|
|
} else if (o instanceof e) {
|
|
t(e.prototype.forEach, o, function (e) {
|
|
n.add(e);
|
|
});
|
|
} else {
|
|
var i, a;
|
|
if (!se(o)) {
|
|
a = n.add;
|
|
if (!ce.IsCallable(a)) {
|
|
throw new TypeError('bad set');
|
|
}
|
|
i = ce.GetIterator(o);
|
|
}
|
|
if (typeof i !== 'undefined') {
|
|
while (true) {
|
|
var u = ce.IteratorStep(i);
|
|
if (u === false) {
|
|
break;
|
|
}
|
|
var f = u.value;
|
|
try {
|
|
t(a, n, f);
|
|
} catch (s) {
|
|
ce.IteratorClose(i, true);
|
|
throw s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var rn = {
|
|
Map: (function () {
|
|
var e = {};
|
|
var r = function MapEntry(e, t) {
|
|
this.key = e;
|
|
this.value = t;
|
|
this.next = null;
|
|
this.prev = null;
|
|
};
|
|
r.prototype.isRemoved = function isRemoved() {
|
|
return this.key === e;
|
|
};
|
|
var n = function isMap(e) {
|
|
return !!e._es6map;
|
|
};
|
|
var o = function requireMapSlot(e, t) {
|
|
if (!ce.TypeIsObject(e) || !n(e)) {
|
|
throw new TypeError(
|
|
'Method Map.prototype.' + t + ' called on incompatible receiver ' + ce.ToString(e)
|
|
);
|
|
}
|
|
};
|
|
var i = function MapIterator(e, t) {
|
|
o(e, '[[MapIterator]]');
|
|
this.head = e._head;
|
|
this.i = this.head;
|
|
this.kind = t;
|
|
};
|
|
i.prototype = {
|
|
isMapIterator: true,
|
|
next: function next() {
|
|
if (!this.isMapIterator) {
|
|
throw new TypeError('Not a MapIterator');
|
|
}
|
|
var e = this.i;
|
|
var t = this.kind;
|
|
var r = this.head;
|
|
if (typeof this.i === 'undefined') {
|
|
return Ke();
|
|
}
|
|
while (e.isRemoved() && e !== r) {
|
|
e = e.prev;
|
|
}
|
|
var n;
|
|
while (e.next !== r) {
|
|
e = e.next;
|
|
if (!e.isRemoved()) {
|
|
if (t === 'key') {
|
|
n = e.key;
|
|
} else if (t === 'value') {
|
|
n = e.value;
|
|
} else {
|
|
n = [e.key, e.value];
|
|
}
|
|
this.i = e;
|
|
return Ke(n);
|
|
}
|
|
}
|
|
this.i = void 0;
|
|
return Ke();
|
|
},
|
|
};
|
|
Me(i.prototype);
|
|
var a;
|
|
var u = function Map() {
|
|
if (!(this instanceof Map)) {
|
|
throw new TypeError('Constructor Map requires "new"');
|
|
}
|
|
if (this && this._es6map) {
|
|
throw new TypeError('Bad construction');
|
|
}
|
|
var e = Ae(this, Map, a, {
|
|
_es6map: true,
|
|
_head: null,
|
|
_map: G ? new G() : null,
|
|
_size: 0,
|
|
_storage: Qr(),
|
|
});
|
|
var t = new r(null, null);
|
|
t.next = t.prev = t;
|
|
e._head = t;
|
|
if (arguments.length > 0) {
|
|
en(Map, e, arguments[0]);
|
|
}
|
|
return e;
|
|
};
|
|
a = u.prototype;
|
|
m.getter(a, 'size', function () {
|
|
if (typeof this._size === 'undefined') {
|
|
throw new TypeError('size method called on incompatible Map');
|
|
}
|
|
return this._size;
|
|
});
|
|
b(a, {
|
|
get: function get(e) {
|
|
o(this, 'get');
|
|
var t;
|
|
var r = Yr(e, true);
|
|
if (r !== null) {
|
|
t = this._storage[r];
|
|
if (t) {
|
|
return t.value;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (this._map) {
|
|
t = V.call(this._map, e);
|
|
if (t) {
|
|
return t.value;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
var n = this._head;
|
|
var i = n;
|
|
while ((i = i.next) !== n) {
|
|
if (ce.SameValueZero(i.key, e)) {
|
|
return i.value;
|
|
}
|
|
}
|
|
},
|
|
has: function has(e) {
|
|
o(this, 'has');
|
|
var t = Yr(e, true);
|
|
if (t !== null) {
|
|
return typeof this._storage[t] !== 'undefined';
|
|
}
|
|
if (this._map) {
|
|
return B.call(this._map, e);
|
|
}
|
|
var r = this._head;
|
|
var n = r;
|
|
while ((n = n.next) !== r) {
|
|
if (ce.SameValueZero(n.key, e)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
set: function set(e, t) {
|
|
o(this, 'set');
|
|
var n = this._head;
|
|
var i = n;
|
|
var a;
|
|
var u = Yr(e, true);
|
|
if (u !== null) {
|
|
if (typeof this._storage[u] !== 'undefined') {
|
|
this._storage[u].value = t;
|
|
return this;
|
|
} else {
|
|
a = this._storage[u] = new r(e, t);
|
|
i = n.prev;
|
|
}
|
|
} else if (this._map) {
|
|
if (B.call(this._map, e)) {
|
|
V.call(this._map, e).value = t;
|
|
} else {
|
|
a = new r(e, t);
|
|
U.call(this._map, e, a);
|
|
i = n.prev;
|
|
}
|
|
}
|
|
while ((i = i.next) !== n) {
|
|
if (ce.SameValueZero(i.key, e)) {
|
|
i.value = t;
|
|
return this;
|
|
}
|
|
}
|
|
a = a || new r(e, t);
|
|
if (ce.SameValue(-0, e)) {
|
|
a.key = +0;
|
|
}
|
|
a.next = this._head;
|
|
a.prev = this._head.prev;
|
|
a.prev.next = a;
|
|
a.next.prev = a;
|
|
this._size += 1;
|
|
return this;
|
|
},
|
|
delete: function (t) {
|
|
o(this, 'delete');
|
|
var r = this._head;
|
|
var n = r;
|
|
var i = Yr(t, true);
|
|
if (i !== null) {
|
|
if (typeof this._storage[i] === 'undefined') {
|
|
return false;
|
|
}
|
|
n = this._storage[i].prev;
|
|
delete this._storage[i];
|
|
} else if (this._map) {
|
|
if (!B.call(this._map, t)) {
|
|
return false;
|
|
}
|
|
n = V.call(this._map, t).prev;
|
|
H.call(this._map, t);
|
|
}
|
|
while ((n = n.next) !== r) {
|
|
if (ce.SameValueZero(n.key, t)) {
|
|
n.key = e;
|
|
n.value = e;
|
|
n.prev.next = n.next;
|
|
n.next.prev = n.prev;
|
|
this._size -= 1;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
clear: function clear() {
|
|
o(this, 'clear');
|
|
this._map = G ? new G() : null;
|
|
this._size = 0;
|
|
this._storage = Qr();
|
|
var t = this._head;
|
|
var r = t;
|
|
var n = r.next;
|
|
while ((r = n) !== t) {
|
|
r.key = e;
|
|
r.value = e;
|
|
n = r.next;
|
|
r.next = r.prev = t;
|
|
}
|
|
t.next = t.prev = t;
|
|
},
|
|
keys: function keys() {
|
|
o(this, 'keys');
|
|
return new i(this, 'key');
|
|
},
|
|
values: function values() {
|
|
o(this, 'values');
|
|
return new i(this, 'value');
|
|
},
|
|
entries: function entries() {
|
|
o(this, 'entries');
|
|
return new i(this, 'key+value');
|
|
},
|
|
forEach: function forEach(e) {
|
|
o(this, 'forEach');
|
|
var r = arguments.length > 1 ? arguments[1] : null;
|
|
var n = this.entries();
|
|
for (var i = n.next(); !i.done; i = n.next()) {
|
|
if (r) {
|
|
t(e, r, i.value[1], i.value[0], this);
|
|
} else {
|
|
e(i.value[1], i.value[0], this);
|
|
}
|
|
}
|
|
},
|
|
});
|
|
Me(a, a.entries);
|
|
return u;
|
|
})(),
|
|
Set: (function () {
|
|
var e = function isSet(e) {
|
|
return e._es6set && typeof e._storage !== 'undefined';
|
|
};
|
|
var r = function requireSetSlot(t, r) {
|
|
if (!ce.TypeIsObject(t) || !e(t)) {
|
|
throw new TypeError(
|
|
'Set.prototype.' + r + ' called on incompatible receiver ' + ce.ToString(t)
|
|
);
|
|
}
|
|
};
|
|
var o;
|
|
var i = function Set() {
|
|
if (!(this instanceof Set)) {
|
|
throw new TypeError('Constructor Set requires "new"');
|
|
}
|
|
if (this && this._es6set) {
|
|
throw new TypeError('Bad construction');
|
|
}
|
|
var e = Ae(this, Set, o, {
|
|
_es6set: true,
|
|
'[[SetData]]': null,
|
|
_storage: Qr(),
|
|
});
|
|
if (!e._es6set) {
|
|
throw new TypeError('bad set');
|
|
}
|
|
if (arguments.length > 0) {
|
|
tn(Set, e, arguments[0]);
|
|
}
|
|
return e;
|
|
};
|
|
o = i.prototype;
|
|
var a = function (e) {
|
|
var t = e;
|
|
if (t === '^null') {
|
|
return null;
|
|
} else if (t === '^undefined') {
|
|
return void 0;
|
|
} else {
|
|
var r = t.charAt(0);
|
|
if (r === '$') {
|
|
return C(t, 1);
|
|
} else if (r === 'n') {
|
|
return +C(t, 1);
|
|
} else if (r === 'b') {
|
|
return t === 'btrue';
|
|
}
|
|
}
|
|
return +t;
|
|
};
|
|
var u = function ensureMap(e) {
|
|
if (!e['[[SetData]]']) {
|
|
var t = new rn.Map();
|
|
e['[[SetData]]'] = t;
|
|
l(n(e._storage), function (e) {
|
|
var r = a(e);
|
|
t.set(r, r);
|
|
});
|
|
e['[[SetData]]'] = t;
|
|
}
|
|
e._storage = null;
|
|
};
|
|
m.getter(i.prototype, 'size', function () {
|
|
r(this, 'size');
|
|
if (this._storage) {
|
|
return n(this._storage).length;
|
|
}
|
|
u(this);
|
|
return this['[[SetData]]'].size;
|
|
});
|
|
b(i.prototype, {
|
|
has: function has(e) {
|
|
r(this, 'has');
|
|
var t;
|
|
if (this._storage && (t = Yr(e)) !== null) {
|
|
return !!this._storage[t];
|
|
}
|
|
u(this);
|
|
return this['[[SetData]]'].has(e);
|
|
},
|
|
add: function add(e) {
|
|
r(this, 'add');
|
|
var t;
|
|
if (this._storage && (t = Yr(e)) !== null) {
|
|
this._storage[t] = true;
|
|
return this;
|
|
}
|
|
u(this);
|
|
this['[[SetData]]'].set(e, e);
|
|
return this;
|
|
},
|
|
delete: function (e) {
|
|
r(this, 'delete');
|
|
var t;
|
|
if (this._storage && (t = Yr(e)) !== null) {
|
|
var n = z(this._storage, t);
|
|
return delete this._storage[t] && n;
|
|
}
|
|
u(this);
|
|
return this['[[SetData]]']['delete'](e);
|
|
},
|
|
clear: function clear() {
|
|
r(this, 'clear');
|
|
if (this._storage) {
|
|
this._storage = Qr();
|
|
}
|
|
if (this['[[SetData]]']) {
|
|
this['[[SetData]]'].clear();
|
|
}
|
|
},
|
|
values: function values() {
|
|
r(this, 'values');
|
|
u(this);
|
|
return new f(this['[[SetData]]'].values());
|
|
},
|
|
entries: function entries() {
|
|
r(this, 'entries');
|
|
u(this);
|
|
return new f(this['[[SetData]]'].entries());
|
|
},
|
|
forEach: function forEach(e) {
|
|
r(this, 'forEach');
|
|
var n = arguments.length > 1 ? arguments[1] : null;
|
|
var o = this;
|
|
u(o);
|
|
this['[[SetData]]'].forEach(function (r, i) {
|
|
if (n) {
|
|
t(e, n, i, i, o);
|
|
} else {
|
|
e(i, i, o);
|
|
}
|
|
});
|
|
},
|
|
});
|
|
h(i.prototype, 'keys', i.prototype.values, true);
|
|
Me(i.prototype, i.prototype.values);
|
|
var f = function SetIterator(e) {
|
|
this.it = e;
|
|
};
|
|
f.prototype = {
|
|
isSetIterator: true,
|
|
next: function next() {
|
|
if (!this.isSetIterator) {
|
|
throw new TypeError('Not a SetIterator');
|
|
}
|
|
return this.it.next();
|
|
},
|
|
};
|
|
Me(f.prototype);
|
|
return i;
|
|
})(),
|
|
};
|
|
var nn =
|
|
S.Set &&
|
|
!Set.prototype['delete'] &&
|
|
Set.prototype.remove &&
|
|
Set.prototype.items &&
|
|
Set.prototype.map &&
|
|
Array.isArray(new Set().keys);
|
|
if (nn) {
|
|
S.Set = rn.Set;
|
|
}
|
|
if (S.Map || S.Set) {
|
|
var on = a(function () {
|
|
return new Map([[1, 2]]).get(1) === 2;
|
|
});
|
|
if (!on) {
|
|
S.Map = function Map() {
|
|
if (!(this instanceof Map)) {
|
|
throw new TypeError('Constructor Map requires "new"');
|
|
}
|
|
var e = new G();
|
|
if (arguments.length > 0) {
|
|
en(Map, e, arguments[0]);
|
|
}
|
|
delete e.constructor;
|
|
Object.setPrototypeOf(e, S.Map.prototype);
|
|
return e;
|
|
};
|
|
S.Map.prototype = O(G.prototype);
|
|
h(S.Map.prototype, 'constructor', S.Map, true);
|
|
m.preserveToString(S.Map, G);
|
|
}
|
|
var an = new Map();
|
|
var un = (function () {
|
|
var e = new Map([
|
|
[1, 0],
|
|
[2, 0],
|
|
[3, 0],
|
|
[4, 0],
|
|
]);
|
|
e.set(-0, e);
|
|
return e.get(0) === e && e.get(-0) === e && e.has(0) && e.has(-0);
|
|
})();
|
|
var fn = an.set(1, 2) === an;
|
|
if (!un || !fn) {
|
|
ne(Map.prototype, 'set', function set(e, r) {
|
|
t(U, this, e === 0 ? 0 : e, r);
|
|
return this;
|
|
});
|
|
}
|
|
if (!un) {
|
|
b(
|
|
Map.prototype,
|
|
{
|
|
get: function get(e) {
|
|
return t(V, this, e === 0 ? 0 : e);
|
|
},
|
|
has: function has(e) {
|
|
return t(B, this, e === 0 ? 0 : e);
|
|
},
|
|
},
|
|
true
|
|
);
|
|
m.preserveToString(Map.prototype.get, V);
|
|
m.preserveToString(Map.prototype.has, B);
|
|
}
|
|
var sn = new Set();
|
|
var cn =
|
|
Set.prototype['delete'] &&
|
|
Set.prototype.add &&
|
|
Set.prototype.has &&
|
|
(function (e) {
|
|
e['delete'](0);
|
|
e.add(-0);
|
|
return !e.has(0);
|
|
})(sn);
|
|
var ln = sn.add(1) === sn;
|
|
if (!cn || !ln) {
|
|
var pn = Set.prototype.add;
|
|
Set.prototype.add = function add(e) {
|
|
t(pn, this, e === 0 ? 0 : e);
|
|
return this;
|
|
};
|
|
m.preserveToString(Set.prototype.add, pn);
|
|
}
|
|
if (!cn) {
|
|
var vn = Set.prototype.has;
|
|
Set.prototype.has = function has(e) {
|
|
return t(vn, this, e === 0 ? 0 : e);
|
|
};
|
|
m.preserveToString(Set.prototype.has, vn);
|
|
var yn = Set.prototype['delete'];
|
|
Set.prototype['delete'] = function SetDelete(e) {
|
|
return t(yn, this, e === 0 ? 0 : e);
|
|
};
|
|
m.preserveToString(Set.prototype['delete'], yn);
|
|
}
|
|
var hn = w(S.Map, function (e) {
|
|
var t = new e([]);
|
|
t.set(42, 42);
|
|
return t instanceof e;
|
|
});
|
|
var bn = Object.setPrototypeOf && !hn;
|
|
var gn = (function () {
|
|
try {
|
|
return !(S.Map() instanceof S.Map);
|
|
} catch (e) {
|
|
return e instanceof TypeError;
|
|
}
|
|
})();
|
|
if (S.Map.length !== 0 || bn || !gn) {
|
|
S.Map = function Map() {
|
|
if (!(this instanceof Map)) {
|
|
throw new TypeError('Constructor Map requires "new"');
|
|
}
|
|
var e = new G();
|
|
if (arguments.length > 0) {
|
|
en(Map, e, arguments[0]);
|
|
}
|
|
delete e.constructor;
|
|
Object.setPrototypeOf(e, Map.prototype);
|
|
return e;
|
|
};
|
|
S.Map.prototype = G.prototype;
|
|
h(S.Map.prototype, 'constructor', S.Map, true);
|
|
m.preserveToString(S.Map, G);
|
|
}
|
|
var dn = w(S.Set, function (e) {
|
|
var t = new e([]);
|
|
t.add(42, 42);
|
|
return t instanceof e;
|
|
});
|
|
var mn = Object.setPrototypeOf && !dn;
|
|
var On = (function () {
|
|
try {
|
|
return !(S.Set() instanceof S.Set);
|
|
} catch (e) {
|
|
return e instanceof TypeError;
|
|
}
|
|
})();
|
|
if (S.Set.length !== 0 || mn || !On) {
|
|
var wn = S.Set;
|
|
S.Set = function Set() {
|
|
if (!(this instanceof Set)) {
|
|
throw new TypeError('Constructor Set requires "new"');
|
|
}
|
|
var e = new wn();
|
|
if (arguments.length > 0) {
|
|
tn(Set, e, arguments[0]);
|
|
}
|
|
delete e.constructor;
|
|
Object.setPrototypeOf(e, Set.prototype);
|
|
return e;
|
|
};
|
|
S.Set.prototype = wn.prototype;
|
|
h(S.Set.prototype, 'constructor', S.Set, true);
|
|
m.preserveToString(S.Set, wn);
|
|
}
|
|
var jn = new S.Map();
|
|
var Sn = !a(function () {
|
|
return jn.keys().next().done;
|
|
});
|
|
if (
|
|
typeof S.Map.prototype.clear !== 'function' ||
|
|
new S.Set().size !== 0 ||
|
|
jn.size !== 0 ||
|
|
typeof S.Map.prototype.keys !== 'function' ||
|
|
typeof S.Set.prototype.keys !== 'function' ||
|
|
typeof S.Map.prototype.forEach !== 'function' ||
|
|
typeof S.Set.prototype.forEach !== 'function' ||
|
|
u(S.Map) ||
|
|
u(S.Set) ||
|
|
typeof jn.keys().next !== 'function' ||
|
|
Sn ||
|
|
!hn
|
|
) {
|
|
b(S, { Map: rn.Map, Set: rn.Set }, true);
|
|
}
|
|
if (S.Set.prototype.keys !== S.Set.prototype.values) {
|
|
h(S.Set.prototype, 'keys', S.Set.prototype.values, true);
|
|
}
|
|
Me(Object.getPrototypeOf(new S.Map().keys()));
|
|
Me(Object.getPrototypeOf(new S.Set().keys()));
|
|
if (c && S.Set.prototype.has.name !== 'has') {
|
|
var Tn = S.Set.prototype.has;
|
|
ne(S.Set.prototype, 'has', function has(e) {
|
|
return t(Tn, this, e);
|
|
});
|
|
}
|
|
}
|
|
b(S, rn);
|
|
Ce(S.Map);
|
|
Ce(S.Set);
|
|
}
|
|
var In = function throwUnlessTargetIsObject(e) {
|
|
if (!ce.TypeIsObject(e)) {
|
|
throw new TypeError('target must be an object');
|
|
}
|
|
};
|
|
var En = {
|
|
apply: function apply() {
|
|
return ce.Call(ce.Call, null, arguments);
|
|
},
|
|
construct: function construct(e, t) {
|
|
if (!ce.IsConstructor(e)) {
|
|
throw new TypeError('First argument must be a constructor.');
|
|
}
|
|
var r = arguments.length > 2 ? arguments[2] : e;
|
|
if (!ce.IsConstructor(r)) {
|
|
throw new TypeError('new.target must be a constructor.');
|
|
}
|
|
return ce.Construct(e, t, r, 'internal');
|
|
},
|
|
deleteProperty: function deleteProperty(e, t) {
|
|
In(e);
|
|
if (s) {
|
|
var r = Object.getOwnPropertyDescriptor(e, t);
|
|
if (r && !r.configurable) {
|
|
return false;
|
|
}
|
|
}
|
|
return delete e[t];
|
|
},
|
|
has: function has(e, t) {
|
|
In(e);
|
|
return t in e;
|
|
},
|
|
};
|
|
if (Object.getOwnPropertyNames) {
|
|
Object.assign(En, {
|
|
ownKeys: function ownKeys(e) {
|
|
In(e);
|
|
var t = Object.getOwnPropertyNames(e);
|
|
if (ce.IsCallable(Object.getOwnPropertySymbols)) {
|
|
x(t, Object.getOwnPropertySymbols(e));
|
|
}
|
|
return t;
|
|
},
|
|
});
|
|
}
|
|
var Pn = function ConvertExceptionToBoolean(e) {
|
|
return !i(e);
|
|
};
|
|
if (Object.preventExtensions) {
|
|
Object.assign(En, {
|
|
isExtensible: function isExtensible(e) {
|
|
In(e);
|
|
return Object.isExtensible(e);
|
|
},
|
|
preventExtensions: function preventExtensions(e) {
|
|
In(e);
|
|
return Pn(function () {
|
|
return Object.preventExtensions(e);
|
|
});
|
|
},
|
|
});
|
|
}
|
|
if (s) {
|
|
var Cn = function get(e, t, r) {
|
|
var n = Object.getOwnPropertyDescriptor(e, t);
|
|
if (!n) {
|
|
var o = Object.getPrototypeOf(e);
|
|
if (o === null) {
|
|
return void 0;
|
|
}
|
|
return Cn(o, t, r);
|
|
}
|
|
if ('value' in n) {
|
|
return n.value;
|
|
}
|
|
if (n.get) {
|
|
return ce.Call(n.get, r);
|
|
}
|
|
return void 0;
|
|
};
|
|
var Mn = function set(e, r, n, o) {
|
|
var i = Object.getOwnPropertyDescriptor(e, r);
|
|
if (!i) {
|
|
var a = Object.getPrototypeOf(e);
|
|
if (a !== null) {
|
|
return Mn(a, r, n, o);
|
|
}
|
|
i = {
|
|
value: void 0,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
};
|
|
}
|
|
if ('value' in i) {
|
|
if (!i.writable) {
|
|
return false;
|
|
}
|
|
if (!ce.TypeIsObject(o)) {
|
|
return false;
|
|
}
|
|
var u = Object.getOwnPropertyDescriptor(o, r);
|
|
if (u) {
|
|
return ae.defineProperty(o, r, { value: n });
|
|
} else {
|
|
return ae.defineProperty(o, r, {
|
|
value: n,
|
|
writable: true,
|
|
enumerable: true,
|
|
configurable: true,
|
|
});
|
|
}
|
|
}
|
|
if (i.set) {
|
|
t(i.set, o, n);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
Object.assign(En, {
|
|
defineProperty: function defineProperty(e, t, r) {
|
|
In(e);
|
|
return Pn(function () {
|
|
return Object.defineProperty(e, t, r);
|
|
});
|
|
},
|
|
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(e, t) {
|
|
In(e);
|
|
return Object.getOwnPropertyDescriptor(e, t);
|
|
},
|
|
get: function get(e, t) {
|
|
In(e);
|
|
var r = arguments.length > 2 ? arguments[2] : e;
|
|
return Cn(e, t, r);
|
|
},
|
|
set: function set(e, t, r) {
|
|
In(e);
|
|
var n = arguments.length > 3 ? arguments[3] : e;
|
|
return Mn(e, t, r, n);
|
|
},
|
|
});
|
|
}
|
|
if (Object.getPrototypeOf) {
|
|
var xn = Object.getPrototypeOf;
|
|
En.getPrototypeOf = function getPrototypeOf(e) {
|
|
In(e);
|
|
return xn(e);
|
|
};
|
|
}
|
|
if (Object.setPrototypeOf && En.getPrototypeOf) {
|
|
var Nn = function (e, t) {
|
|
var r = t;
|
|
while (r) {
|
|
if (e === r) {
|
|
return true;
|
|
}
|
|
r = En.getPrototypeOf(r);
|
|
}
|
|
return false;
|
|
};
|
|
Object.assign(En, {
|
|
setPrototypeOf: function setPrototypeOf(e, t) {
|
|
In(e);
|
|
if (t !== null && !ce.TypeIsObject(t)) {
|
|
throw new TypeError('proto must be an object or null');
|
|
}
|
|
if (t === ae.getPrototypeOf(e)) {
|
|
return true;
|
|
}
|
|
if (ae.isExtensible && !ae.isExtensible(e)) {
|
|
return false;
|
|
}
|
|
if (Nn(e, t)) {
|
|
return false;
|
|
}
|
|
Object.setPrototypeOf(e, t);
|
|
return true;
|
|
},
|
|
});
|
|
}
|
|
var An = function (e, t) {
|
|
if (!ce.IsCallable(S.Reflect[e])) {
|
|
h(S.Reflect, e, t);
|
|
} else {
|
|
var r = a(function () {
|
|
S.Reflect[e](1);
|
|
S.Reflect[e](NaN);
|
|
S.Reflect[e](true);
|
|
return true;
|
|
});
|
|
if (r) {
|
|
ne(S.Reflect, e, t);
|
|
}
|
|
}
|
|
};
|
|
Object.keys(En).forEach(function (e) {
|
|
An(e, En[e]);
|
|
});
|
|
var Rn = S.Reflect.getPrototypeOf;
|
|
if (c && Rn && Rn.name !== 'getPrototypeOf') {
|
|
ne(S.Reflect, 'getPrototypeOf', function getPrototypeOf(e) {
|
|
return t(Rn, S.Reflect, e);
|
|
});
|
|
}
|
|
if (S.Reflect.setPrototypeOf) {
|
|
if (
|
|
a(function () {
|
|
S.Reflect.setPrototypeOf(1, {});
|
|
return true;
|
|
})
|
|
) {
|
|
ne(S.Reflect, 'setPrototypeOf', En.setPrototypeOf);
|
|
}
|
|
}
|
|
if (S.Reflect.defineProperty) {
|
|
if (
|
|
!a(function () {
|
|
var e = !S.Reflect.defineProperty(1, 'test', { value: 1 });
|
|
var t =
|
|
typeof Object.preventExtensions !== 'function' ||
|
|
!S.Reflect.defineProperty(Object.preventExtensions({}), 'test', {});
|
|
return e && t;
|
|
})
|
|
) {
|
|
ne(S.Reflect, 'defineProperty', En.defineProperty);
|
|
}
|
|
}
|
|
if (S.Reflect.construct) {
|
|
if (
|
|
!a(function () {
|
|
var e = function F() {};
|
|
return S.Reflect.construct(function () {}, [], e) instanceof e;
|
|
})
|
|
) {
|
|
ne(S.Reflect, 'construct', En.construct);
|
|
}
|
|
}
|
|
if (String(new Date(NaN)) !== 'Invalid Date') {
|
|
var _n = Date.prototype.toString;
|
|
var kn = function toString() {
|
|
var e = +this;
|
|
if (e !== e) {
|
|
return 'Invalid Date';
|
|
}
|
|
return ce.Call(_n, this);
|
|
};
|
|
ne(Date.prototype, 'toString', kn);
|
|
}
|
|
var Ln = {
|
|
anchor: function anchor(e) {
|
|
return ce.CreateHTML(this, 'a', 'name', e);
|
|
},
|
|
big: function big() {
|
|
return ce.CreateHTML(this, 'big', '', '');
|
|
},
|
|
blink: function blink() {
|
|
return ce.CreateHTML(this, 'blink', '', '');
|
|
},
|
|
bold: function bold() {
|
|
return ce.CreateHTML(this, 'b', '', '');
|
|
},
|
|
fixed: function fixed() {
|
|
return ce.CreateHTML(this, 'tt', '', '');
|
|
},
|
|
fontcolor: function fontcolor(e) {
|
|
return ce.CreateHTML(this, 'font', 'color', e);
|
|
},
|
|
fontsize: function fontsize(e) {
|
|
return ce.CreateHTML(this, 'font', 'size', e);
|
|
},
|
|
italics: function italics() {
|
|
return ce.CreateHTML(this, 'i', '', '');
|
|
},
|
|
link: function link(e) {
|
|
return ce.CreateHTML(this, 'a', 'href', e);
|
|
},
|
|
small: function small() {
|
|
return ce.CreateHTML(this, 'small', '', '');
|
|
},
|
|
strike: function strike() {
|
|
return ce.CreateHTML(this, 'strike', '', '');
|
|
},
|
|
sub: function sub() {
|
|
return ce.CreateHTML(this, 'sub', '', '');
|
|
},
|
|
sup: function sub() {
|
|
return ce.CreateHTML(this, 'sup', '', '');
|
|
},
|
|
};
|
|
l(Object.keys(Ln), function (e) {
|
|
var r = String.prototype[e];
|
|
var n = false;
|
|
if (ce.IsCallable(r)) {
|
|
var o = t(r, '', ' " ');
|
|
var i = P([], o.match(/"/g)).length;
|
|
n = o !== o.toLowerCase() || i > 2;
|
|
} else {
|
|
n = true;
|
|
}
|
|
if (n) {
|
|
ne(String.prototype, e, Ln[e]);
|
|
}
|
|
});
|
|
var Fn = (function () {
|
|
if (!oe) {
|
|
return false;
|
|
}
|
|
var e =
|
|
typeof JSON === 'object' && typeof JSON.stringify === 'function' ? JSON.stringify : null;
|
|
if (!e) {
|
|
return false;
|
|
}
|
|
if (typeof e($()) !== 'undefined') {
|
|
return true;
|
|
}
|
|
if (e([$()]) !== '[null]') {
|
|
return true;
|
|
}
|
|
var t = { a: $() };
|
|
t[$()] = true;
|
|
if (e(t) !== '{}') {
|
|
return true;
|
|
}
|
|
return false;
|
|
})();
|
|
var Dn = a(function () {
|
|
if (!oe) {
|
|
return true;
|
|
}
|
|
return JSON.stringify(Object($())) === '{}' && JSON.stringify([Object($())]) === '[{}]';
|
|
});
|
|
if (Fn || !Dn) {
|
|
var zn = JSON.stringify;
|
|
ne(JSON, 'stringify', function stringify(e) {
|
|
if (typeof e === 'symbol') {
|
|
return;
|
|
}
|
|
var n;
|
|
if (arguments.length > 1) {
|
|
n = arguments[1];
|
|
}
|
|
var o = [e];
|
|
if (!r(n)) {
|
|
var i = ce.IsCallable(n) ? n : null;
|
|
var a = function (e, r) {
|
|
var n = i ? t(i, this, e, r) : r;
|
|
if (typeof n !== 'symbol') {
|
|
if (re.symbol(n)) {
|
|
return Nt({})(n);
|
|
} else {
|
|
return n;
|
|
}
|
|
}
|
|
};
|
|
o.push(a);
|
|
} else {
|
|
o.push(n);
|
|
}
|
|
if (arguments.length > 2) {
|
|
o.push(arguments[2]);
|
|
}
|
|
return zn.apply(this, o);
|
|
});
|
|
}
|
|
return S;
|
|
});
|
|
//# sourceMappingURL=es6-shim.map
|