mirror of
https://github.com/Doodle3D/Doodle3D-API
synced 2025-01-11 04:55:09 +01:00
2850 lines
101 KiB
JavaScript
2850 lines
101 KiB
JavaScript
|
/* */
|
||
|
|
"format cjs";
|
||
|
|
(function(process) {
|
||
|
|
!function(undefined) {
|
||
|
|
'use strict';
|
||
|
|
var __e = null,
|
||
|
|
__g = null;
|
||
|
|
(function(modules) {
|
||
|
|
var installedModules = {};
|
||
|
|
function __webpack_require__(moduleId) {
|
||
|
|
if (installedModules[moduleId])
|
||
|
|
return installedModules[moduleId].exports;
|
||
|
|
var module = installedModules[moduleId] = {
|
||
|
|
exports: {},
|
||
|
|
id: moduleId,
|
||
|
|
loaded: false
|
||
|
|
};
|
||
|
|
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
|
|
module.loaded = true;
|
||
|
|
return module.exports;
|
||
|
|
}
|
||
|
|
__webpack_require__.m = modules;
|
||
|
|
__webpack_require__.c = installedModules;
|
||
|
|
__webpack_require__.p = "";
|
||
|
|
return __webpack_require__(0);
|
||
|
|
})([function(module, exports, __webpack_require__) {
|
||
|
|
__webpack_require__(10);
|
||
|
|
__webpack_require__(20);
|
||
|
|
__webpack_require__(24);
|
||
|
|
__webpack_require__(26);
|
||
|
|
__webpack_require__(28);
|
||
|
|
__webpack_require__(30);
|
||
|
|
__webpack_require__(31);
|
||
|
|
__webpack_require__(32);
|
||
|
|
__webpack_require__(33);
|
||
|
|
__webpack_require__(34);
|
||
|
|
__webpack_require__(35);
|
||
|
|
__webpack_require__(36);
|
||
|
|
__webpack_require__(37);
|
||
|
|
__webpack_require__(38);
|
||
|
|
__webpack_require__(39);
|
||
|
|
__webpack_require__(43);
|
||
|
|
__webpack_require__(44);
|
||
|
|
__webpack_require__(45);
|
||
|
|
__webpack_require__(46);
|
||
|
|
__webpack_require__(48);
|
||
|
|
__webpack_require__(49);
|
||
|
|
__webpack_require__(52);
|
||
|
|
__webpack_require__(53);
|
||
|
|
__webpack_require__(54);
|
||
|
|
__webpack_require__(1);
|
||
|
|
__webpack_require__(56);
|
||
|
|
__webpack_require__(57);
|
||
|
|
__webpack_require__(58);
|
||
|
|
__webpack_require__(59);
|
||
|
|
__webpack_require__(60);
|
||
|
|
__webpack_require__(64);
|
||
|
|
__webpack_require__(67);
|
||
|
|
__webpack_require__(68);
|
||
|
|
__webpack_require__(70);
|
||
|
|
__webpack_require__(71);
|
||
|
|
__webpack_require__(73);
|
||
|
|
__webpack_require__(74);
|
||
|
|
__webpack_require__(75);
|
||
|
|
__webpack_require__(77);
|
||
|
|
__webpack_require__(78);
|
||
|
|
__webpack_require__(79);
|
||
|
|
__webpack_require__(80);
|
||
|
|
__webpack_require__(81);
|
||
|
|
__webpack_require__(83);
|
||
|
|
__webpack_require__(84);
|
||
|
|
__webpack_require__(85);
|
||
|
|
__webpack_require__(86);
|
||
|
|
__webpack_require__(88);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
toIndex = $.toIndex;
|
||
|
|
$def($def.P, 'Array', {copyWithin: function copyWithin(target, start) {
|
||
|
|
var O = Object($.assertDefined(this)),
|
||
|
|
len = $.toLength(O.length),
|
||
|
|
to = toIndex(target, len),
|
||
|
|
from = toIndex(start, len),
|
||
|
|
end = arguments[2],
|
||
|
|
fin = end === undefined ? len : toIndex(end, len),
|
||
|
|
count = Math.min(fin - from, len - to),
|
||
|
|
inc = 1;
|
||
|
|
if (from < to && to < from + count) {
|
||
|
|
inc = -1;
|
||
|
|
from = from + count - 1;
|
||
|
|
to = to + count - 1;
|
||
|
|
}
|
||
|
|
while (count-- > 0) {
|
||
|
|
if (from in O)
|
||
|
|
O[to] = O[from];
|
||
|
|
else
|
||
|
|
delete O[to];
|
||
|
|
to += inc;
|
||
|
|
from += inc;
|
||
|
|
}
|
||
|
|
return O;
|
||
|
|
}});
|
||
|
|
__webpack_require__(7)('copyWithin');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var global = typeof self != 'undefined' ? self : Function('return this')(),
|
||
|
|
core = {},
|
||
|
|
defineProperty = Object.defineProperty,
|
||
|
|
hasOwnProperty = {}.hasOwnProperty,
|
||
|
|
ceil = Math.ceil,
|
||
|
|
floor = Math.floor,
|
||
|
|
max = Math.max,
|
||
|
|
min = Math.min;
|
||
|
|
var DESC = !!function() {
|
||
|
|
try {
|
||
|
|
return defineProperty({}, 'a', {get: function() {
|
||
|
|
return 2;
|
||
|
|
}}).a == 2;
|
||
|
|
} catch (e) {}
|
||
|
|
}();
|
||
|
|
var hide = createDefiner(1);
|
||
|
|
function toInteger(it) {
|
||
|
|
return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
|
||
|
|
}
|
||
|
|
function desc(bitmap, value) {
|
||
|
|
return {
|
||
|
|
enumerable: !(bitmap & 1),
|
||
|
|
configurable: !(bitmap & 2),
|
||
|
|
writable: !(bitmap & 4),
|
||
|
|
value: value
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function simpleSet(object, key, value) {
|
||
|
|
object[key] = value;
|
||
|
|
return object;
|
||
|
|
}
|
||
|
|
function createDefiner(bitmap) {
|
||
|
|
return DESC ? function(object, key, value) {
|
||
|
|
return $.setDesc(object, key, desc(bitmap, value));
|
||
|
|
} : simpleSet;
|
||
|
|
}
|
||
|
|
function isObject(it) {
|
||
|
|
return it !== null && (typeof it == 'object' || typeof it == 'function');
|
||
|
|
}
|
||
|
|
function isFunction(it) {
|
||
|
|
return typeof it == 'function';
|
||
|
|
}
|
||
|
|
function assertDefined(it) {
|
||
|
|
if (it == undefined)
|
||
|
|
throw TypeError("Can't call method on " + it);
|
||
|
|
return it;
|
||
|
|
}
|
||
|
|
var $ = module.exports = __webpack_require__(3)({
|
||
|
|
g: global,
|
||
|
|
core: core,
|
||
|
|
html: global.document && document.documentElement,
|
||
|
|
isObject: isObject,
|
||
|
|
isFunction: isFunction,
|
||
|
|
that: function() {
|
||
|
|
return this;
|
||
|
|
},
|
||
|
|
toInteger: toInteger,
|
||
|
|
toLength: function(it) {
|
||
|
|
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0;
|
||
|
|
},
|
||
|
|
toIndex: function(index, length) {
|
||
|
|
index = toInteger(index);
|
||
|
|
return index < 0 ? max(index + length, 0) : min(index, length);
|
||
|
|
},
|
||
|
|
has: function(it, key) {
|
||
|
|
return hasOwnProperty.call(it, key);
|
||
|
|
},
|
||
|
|
create: Object.create,
|
||
|
|
getProto: Object.getPrototypeOf,
|
||
|
|
DESC: DESC,
|
||
|
|
desc: desc,
|
||
|
|
getDesc: Object.getOwnPropertyDescriptor,
|
||
|
|
setDesc: defineProperty,
|
||
|
|
setDescs: Object.defineProperties,
|
||
|
|
getKeys: Object.keys,
|
||
|
|
getNames: Object.getOwnPropertyNames,
|
||
|
|
getSymbols: Object.getOwnPropertySymbols,
|
||
|
|
assertDefined: assertDefined,
|
||
|
|
ES5Object: Object,
|
||
|
|
toObject: function(it) {
|
||
|
|
return $.ES5Object(assertDefined(it));
|
||
|
|
},
|
||
|
|
hide: hide,
|
||
|
|
def: createDefiner(0),
|
||
|
|
set: global.Symbol ? simpleSet : hide,
|
||
|
|
each: [].forEach
|
||
|
|
});
|
||
|
|
if (typeof __e != 'undefined')
|
||
|
|
__e = core;
|
||
|
|
if (typeof __g != 'undefined')
|
||
|
|
__g = global;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
module.exports = function($) {
|
||
|
|
$.FW = true;
|
||
|
|
$.path = $.g;
|
||
|
|
return $;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
global = $.g,
|
||
|
|
core = $.core,
|
||
|
|
isFunction = $.isFunction,
|
||
|
|
$redef = __webpack_require__(5);
|
||
|
|
function ctx(fn, that) {
|
||
|
|
return function() {
|
||
|
|
return fn.apply(that, arguments);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
global.core = core;
|
||
|
|
$def.F = 1;
|
||
|
|
$def.G = 2;
|
||
|
|
$def.S = 4;
|
||
|
|
$def.P = 8;
|
||
|
|
$def.B = 16;
|
||
|
|
$def.W = 32;
|
||
|
|
function $def(type, name, source) {
|
||
|
|
var key,
|
||
|
|
own,
|
||
|
|
out,
|
||
|
|
exp,
|
||
|
|
isGlobal = type & $def.G,
|
||
|
|
isProto = type & $def.P,
|
||
|
|
target = isGlobal ? global : type & $def.S ? global[name] : (global[name] || {}).prototype,
|
||
|
|
exports = isGlobal ? core : core[name] || (core[name] = {});
|
||
|
|
if (isGlobal)
|
||
|
|
source = name;
|
||
|
|
for (key in source) {
|
||
|
|
own = !(type & $def.F) && target && key in target;
|
||
|
|
out = (own ? target : source)[key];
|
||
|
|
if (type & $def.B && own)
|
||
|
|
exp = ctx(out, global);
|
||
|
|
else
|
||
|
|
exp = isProto && isFunction(out) ? ctx(Function.call, out) : out;
|
||
|
|
if (target && !own)
|
||
|
|
$redef(target, key, out);
|
||
|
|
if (exports[key] != out)
|
||
|
|
$.hide(exports, key, exp);
|
||
|
|
if (isProto)
|
||
|
|
(exports.prototype || (exports.prototype = {}))[key] = out;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
module.exports = $def;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
tpl = String({}.hasOwnProperty),
|
||
|
|
SRC = __webpack_require__(6).safe('src'),
|
||
|
|
_toString = Function.toString;
|
||
|
|
function $redef(O, key, val, safe) {
|
||
|
|
if ($.isFunction(val)) {
|
||
|
|
var base = O[key];
|
||
|
|
$.hide(val, SRC, base ? String(base) : tpl.replace(/hasOwnProperty/, String(key)));
|
||
|
|
if (!('name' in val))
|
||
|
|
val.name = key;
|
||
|
|
}
|
||
|
|
if (O === $.g) {
|
||
|
|
O[key] = val;
|
||
|
|
} else {
|
||
|
|
if (!safe)
|
||
|
|
delete O[key];
|
||
|
|
$.hide(O, key, val);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$redef(Function.prototype, 'toString', function toString() {
|
||
|
|
return $.has(this, SRC) ? this[SRC] : _toString.call(this);
|
||
|
|
});
|
||
|
|
$.core.inspectSource = function(it) {
|
||
|
|
return _toString.call(it);
|
||
|
|
};
|
||
|
|
module.exports = $redef;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var sid = 0;
|
||
|
|
function uid(key) {
|
||
|
|
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++sid + Math.random()).toString(36));
|
||
|
|
}
|
||
|
|
uid.safe = __webpack_require__(2).g.Symbol || uid;
|
||
|
|
module.exports = uid;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var UNSCOPABLES = __webpack_require__(8)('unscopables');
|
||
|
|
if (!(UNSCOPABLES in []))
|
||
|
|
__webpack_require__(2).hide(Array.prototype, UNSCOPABLES, {});
|
||
|
|
module.exports = function(key) {
|
||
|
|
[][UNSCOPABLES][key] = true;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var global = __webpack_require__(2).g,
|
||
|
|
store = __webpack_require__(9)('wks');
|
||
|
|
module.exports = function(name) {
|
||
|
|
return store[name] || (store[name] = global.Symbol && global.Symbol[name] || __webpack_require__(6).safe('Symbol.' + name));
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
SHARED = '__core-js_shared__',
|
||
|
|
store = $.g[SHARED] || ($.g[SHARED] = {});
|
||
|
|
module.exports = function(key) {
|
||
|
|
return store[key] || (store[key] = {});
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cel = __webpack_require__(11),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
invoke = __webpack_require__(13),
|
||
|
|
arrayMethod = __webpack_require__(14),
|
||
|
|
IE_PROTO = __webpack_require__(6).safe('__proto__'),
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
assertObject = assert.obj,
|
||
|
|
ObjectProto = Object.prototype,
|
||
|
|
html = $.html,
|
||
|
|
A = [],
|
||
|
|
_slice = A.slice,
|
||
|
|
_join = A.join,
|
||
|
|
classof = cof.classof,
|
||
|
|
has = $.has,
|
||
|
|
defineProperty = $.setDesc,
|
||
|
|
getOwnDescriptor = $.getDesc,
|
||
|
|
defineProperties = $.setDescs,
|
||
|
|
isFunction = $.isFunction,
|
||
|
|
isObject = $.isObject,
|
||
|
|
toObject = $.toObject,
|
||
|
|
toLength = $.toLength,
|
||
|
|
toIndex = $.toIndex,
|
||
|
|
IE8_DOM_DEFINE = false,
|
||
|
|
$indexOf = __webpack_require__(17)(false),
|
||
|
|
$forEach = arrayMethod(0),
|
||
|
|
$map = arrayMethod(1),
|
||
|
|
$filter = arrayMethod(2),
|
||
|
|
$some = arrayMethod(3),
|
||
|
|
$every = arrayMethod(4);
|
||
|
|
if (!$.DESC) {
|
||
|
|
try {
|
||
|
|
IE8_DOM_DEFINE = defineProperty(cel('div'), 'x', {get: function() {
|
||
|
|
return 8;
|
||
|
|
}}).x == 8;
|
||
|
|
} catch (e) {}
|
||
|
|
$.setDesc = function(O, P, Attributes) {
|
||
|
|
if (IE8_DOM_DEFINE)
|
||
|
|
try {
|
||
|
|
return defineProperty(O, P, Attributes);
|
||
|
|
} catch (e) {}
|
||
|
|
if ('get' in Attributes || 'set' in Attributes)
|
||
|
|
throw TypeError('Accessors not supported!');
|
||
|
|
if ('value' in Attributes)
|
||
|
|
assertObject(O)[P] = Attributes.value;
|
||
|
|
return O;
|
||
|
|
};
|
||
|
|
$.getDesc = function(O, P) {
|
||
|
|
if (IE8_DOM_DEFINE)
|
||
|
|
try {
|
||
|
|
return getOwnDescriptor(O, P);
|
||
|
|
} catch (e) {}
|
||
|
|
if (has(O, P))
|
||
|
|
return $.desc(!ObjectProto.propertyIsEnumerable.call(O, P), O[P]);
|
||
|
|
};
|
||
|
|
$.setDescs = defineProperties = function(O, Properties) {
|
||
|
|
assertObject(O);
|
||
|
|
var keys = $.getKeys(Properties),
|
||
|
|
length = keys.length,
|
||
|
|
i = 0,
|
||
|
|
P;
|
||
|
|
while (length > i)
|
||
|
|
$.setDesc(O, P = keys[i++], Properties[P]);
|
||
|
|
return O;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
$def($def.S + $def.F * !$.DESC, 'Object', {
|
||
|
|
getOwnPropertyDescriptor: $.getDesc,
|
||
|
|
defineProperty: $.setDesc,
|
||
|
|
defineProperties: defineProperties
|
||
|
|
});
|
||
|
|
var keys1 = ('constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,' + 'toLocaleString,toString,valueOf').split(','),
|
||
|
|
keys2 = keys1.concat('length', 'prototype'),
|
||
|
|
keysLen1 = keys1.length;
|
||
|
|
var createDict = function() {
|
||
|
|
var iframe = cel('iframe'),
|
||
|
|
i = keysLen1,
|
||
|
|
gt = '>',
|
||
|
|
iframeDocument;
|
||
|
|
iframe.style.display = 'none';
|
||
|
|
html.appendChild(iframe);
|
||
|
|
iframe.src = 'javascript:';
|
||
|
|
iframeDocument = iframe.contentWindow.document;
|
||
|
|
iframeDocument.open();
|
||
|
|
iframeDocument.write('<script>document.F=Object</script' + gt);
|
||
|
|
iframeDocument.close();
|
||
|
|
createDict = iframeDocument.F;
|
||
|
|
while (i--)
|
||
|
|
delete createDict.prototype[keys1[i]];
|
||
|
|
return createDict();
|
||
|
|
};
|
||
|
|
function createGetKeys(names, length) {
|
||
|
|
return function(object) {
|
||
|
|
var O = toObject(object),
|
||
|
|
i = 0,
|
||
|
|
result = [],
|
||
|
|
key;
|
||
|
|
for (key in O)
|
||
|
|
if (key != IE_PROTO)
|
||
|
|
has(O, key) && result.push(key);
|
||
|
|
while (length > i)
|
||
|
|
if (has(O, key = names[i++])) {
|
||
|
|
~$indexOf(result, key) || result.push(key);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function Empty() {}
|
||
|
|
$def($def.S, 'Object', {
|
||
|
|
getPrototypeOf: $.getProto = $.getProto || function(O) {
|
||
|
|
O = Object(assert.def(O));
|
||
|
|
if (has(O, IE_PROTO))
|
||
|
|
return O[IE_PROTO];
|
||
|
|
if (isFunction(O.constructor) && O instanceof O.constructor) {
|
||
|
|
return O.constructor.prototype;
|
||
|
|
}
|
||
|
|
return O instanceof Object ? ObjectProto : null;
|
||
|
|
},
|
||
|
|
getOwnPropertyNames: $.getNames = $.getNames || createGetKeys(keys2, keys2.length, true),
|
||
|
|
create: $.create = $.create || function(O, Properties) {
|
||
|
|
var result;
|
||
|
|
if (O !== null) {
|
||
|
|
Empty.prototype = assertObject(O);
|
||
|
|
result = new Empty();
|
||
|
|
Empty.prototype = null;
|
||
|
|
result[IE_PROTO] = O;
|
||
|
|
} else
|
||
|
|
result = createDict();
|
||
|
|
return Properties === undefined ? result : defineProperties(result, Properties);
|
||
|
|
},
|
||
|
|
keys: $.getKeys = $.getKeys || createGetKeys(keys1, keysLen1, false),
|
||
|
|
seal: function seal(it) {
|
||
|
|
return it;
|
||
|
|
},
|
||
|
|
freeze: function freeze(it) {
|
||
|
|
return it;
|
||
|
|
},
|
||
|
|
preventExtensions: function preventExtensions(it) {
|
||
|
|
return it;
|
||
|
|
},
|
||
|
|
isSealed: function isSealed(it) {
|
||
|
|
return !isObject(it);
|
||
|
|
},
|
||
|
|
isFrozen: function isFrozen(it) {
|
||
|
|
return !isObject(it);
|
||
|
|
},
|
||
|
|
isExtensible: function isExtensible(it) {
|
||
|
|
return isObject(it);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
$def($def.P, 'Function', {bind: function(that) {
|
||
|
|
var fn = assert.fn(this),
|
||
|
|
partArgs = _slice.call(arguments, 1);
|
||
|
|
function bound() {
|
||
|
|
var args = partArgs.concat(_slice.call(arguments)),
|
||
|
|
constr = this instanceof bound,
|
||
|
|
ctx = constr ? $.create(fn.prototype) : that,
|
||
|
|
result = invoke(fn, args, ctx);
|
||
|
|
return constr ? ctx : result;
|
||
|
|
}
|
||
|
|
if (fn.prototype)
|
||
|
|
bound.prototype = fn.prototype;
|
||
|
|
return bound;
|
||
|
|
}});
|
||
|
|
if (!(0 in Object('z') && 'z'[0] == 'z')) {
|
||
|
|
$.ES5Object = function(it) {
|
||
|
|
return cof(it) == 'String' ? it.split('') : Object(it);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
var buggySlice = true;
|
||
|
|
try {
|
||
|
|
if (html)
|
||
|
|
_slice.call(html);
|
||
|
|
buggySlice = false;
|
||
|
|
} catch (e) {}
|
||
|
|
$def($def.P + $def.F * buggySlice, 'Array', {slice: function slice(begin, end) {
|
||
|
|
var len = toLength(this.length),
|
||
|
|
klass = cof(this);
|
||
|
|
end = end === undefined ? len : end;
|
||
|
|
if (klass == 'Array')
|
||
|
|
return _slice.call(this, begin, end);
|
||
|
|
var start = toIndex(begin, len),
|
||
|
|
upTo = toIndex(end, len),
|
||
|
|
size = toLength(upTo - start),
|
||
|
|
cloned = Array(size),
|
||
|
|
i = 0;
|
||
|
|
for (; i < size; i++)
|
||
|
|
cloned[i] = klass == 'String' ? this.charAt(start + i) : this[start + i];
|
||
|
|
return cloned;
|
||
|
|
}});
|
||
|
|
$def($def.P + $def.F * ($.ES5Object != Object), 'Array', {join: function join() {
|
||
|
|
return _join.apply($.ES5Object(this), arguments);
|
||
|
|
}});
|
||
|
|
$def($def.S, 'Array', {isArray: function(arg) {
|
||
|
|
return cof(arg) == 'Array';
|
||
|
|
}});
|
||
|
|
function createArrayReduce(isRight) {
|
||
|
|
return function(callbackfn, memo) {
|
||
|
|
assert.fn(callbackfn);
|
||
|
|
var O = toObject(this),
|
||
|
|
length = toLength(O.length),
|
||
|
|
index = isRight ? length - 1 : 0,
|
||
|
|
i = isRight ? -1 : 1;
|
||
|
|
if (arguments.length < 2)
|
||
|
|
for (; ; ) {
|
||
|
|
if (index in O) {
|
||
|
|
memo = O[index];
|
||
|
|
index += i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
index += i;
|
||
|
|
assert(isRight ? index >= 0 : length > index, 'Reduce of empty array with no initial value');
|
||
|
|
}
|
||
|
|
for (; isRight ? index >= 0 : length > index; index += i)
|
||
|
|
if (index in O) {
|
||
|
|
memo = callbackfn(memo, O[index], index, this);
|
||
|
|
}
|
||
|
|
return memo;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
$def($def.P, 'Array', {
|
||
|
|
forEach: $.each = $.each || function forEach(callbackfn) {
|
||
|
|
return $forEach(this, callbackfn, arguments[1]);
|
||
|
|
},
|
||
|
|
map: function map(callbackfn) {
|
||
|
|
return $map(this, callbackfn, arguments[1]);
|
||
|
|
},
|
||
|
|
filter: function filter(callbackfn) {
|
||
|
|
return $filter(this, callbackfn, arguments[1]);
|
||
|
|
},
|
||
|
|
some: function some(callbackfn) {
|
||
|
|
return $some(this, callbackfn, arguments[1]);
|
||
|
|
},
|
||
|
|
every: function every(callbackfn) {
|
||
|
|
return $every(this, callbackfn, arguments[1]);
|
||
|
|
},
|
||
|
|
reduce: createArrayReduce(false),
|
||
|
|
reduceRight: createArrayReduce(true),
|
||
|
|
indexOf: function indexOf(el) {
|
||
|
|
return $indexOf(this, el, arguments[1]);
|
||
|
|
},
|
||
|
|
lastIndexOf: function(el, fromIndex) {
|
||
|
|
var O = toObject(this),
|
||
|
|
length = toLength(O.length),
|
||
|
|
index = length - 1;
|
||
|
|
if (arguments.length > 1)
|
||
|
|
index = Math.min(index, $.toInteger(fromIndex));
|
||
|
|
if (index < 0)
|
||
|
|
index = toLength(length + index);
|
||
|
|
for (; index >= 0; index--)
|
||
|
|
if (index in O)
|
||
|
|
if (O[index] === el)
|
||
|
|
return index;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
$def($def.P, 'String', {trim: __webpack_require__(18)(/^\s*([\s\S]*\S)?\s*$/, '$1')});
|
||
|
|
$def($def.S, 'Date', {now: function() {
|
||
|
|
return +new Date;
|
||
|
|
}});
|
||
|
|
function lz(num) {
|
||
|
|
return num > 9 ? num : '0' + num;
|
||
|
|
}
|
||
|
|
var date = new Date(-5e13 - 1),
|
||
|
|
brokenDate = !(date.toISOString && date.toISOString() == '0385-07-25T07:06:39.999Z' && __webpack_require__(19)(function() {
|
||
|
|
new Date(NaN).toISOString();
|
||
|
|
}));
|
||
|
|
$def($def.P + $def.F * brokenDate, 'Date', {toISOString: function() {
|
||
|
|
if (!isFinite(this))
|
||
|
|
throw RangeError('Invalid time value');
|
||
|
|
var d = this,
|
||
|
|
y = d.getUTCFullYear(),
|
||
|
|
m = d.getUTCMilliseconds(),
|
||
|
|
s = y < 0 ? '-' : y > 9999 ? '+' : '';
|
||
|
|
return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) + '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) + 'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) + ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
|
||
|
|
}});
|
||
|
|
if (classof(function() {
|
||
|
|
return arguments;
|
||
|
|
}()) == 'Object')
|
||
|
|
cof.classof = function(it) {
|
||
|
|
var tag = classof(it);
|
||
|
|
return tag == 'Object' && isFunction(it.callee) ? 'Arguments' : tag;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
document = $.g.document,
|
||
|
|
isObject = $.isObject,
|
||
|
|
is = isObject(document) && isObject(document.createElement);
|
||
|
|
module.exports = function(it) {
|
||
|
|
return is ? document.createElement(it) : {};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
TAG = __webpack_require__(8)('toStringTag'),
|
||
|
|
toString = {}.toString;
|
||
|
|
function cof(it) {
|
||
|
|
return toString.call(it).slice(8, -1);
|
||
|
|
}
|
||
|
|
cof.classof = function(it) {
|
||
|
|
var O,
|
||
|
|
T;
|
||
|
|
return it == undefined ? it === undefined ? 'Undefined' : 'Null' : typeof(T = (O = Object(it))[TAG]) == 'string' ? T : cof(O);
|
||
|
|
};
|
||
|
|
cof.set = function(it, tag, stat) {
|
||
|
|
if (it && !$.has(it = stat ? it : it.prototype, TAG))
|
||
|
|
$.hide(it, TAG, tag);
|
||
|
|
};
|
||
|
|
module.exports = cof;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
module.exports = function(fn, args, that) {
|
||
|
|
var un = that === undefined;
|
||
|
|
switch (args.length) {
|
||
|
|
case 0:
|
||
|
|
return un ? fn() : fn.call(that);
|
||
|
|
case 1:
|
||
|
|
return un ? fn(args[0]) : fn.call(that, args[0]);
|
||
|
|
case 2:
|
||
|
|
return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);
|
||
|
|
case 3:
|
||
|
|
return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]);
|
||
|
|
case 4:
|
||
|
|
return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]);
|
||
|
|
case 5:
|
||
|
|
return un ? fn(args[0], args[1], args[2], args[3], args[4]) : fn.call(that, args[0], args[1], args[2], args[3], args[4]);
|
||
|
|
}
|
||
|
|
return fn.apply(that, args);
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
ctx = __webpack_require__(15);
|
||
|
|
module.exports = function(TYPE) {
|
||
|
|
var IS_MAP = TYPE == 1,
|
||
|
|
IS_FILTER = TYPE == 2,
|
||
|
|
IS_SOME = TYPE == 3,
|
||
|
|
IS_EVERY = TYPE == 4,
|
||
|
|
IS_FIND_INDEX = TYPE == 6,
|
||
|
|
NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
|
||
|
|
return function($this, callbackfn, that) {
|
||
|
|
var O = Object($.assertDefined($this)),
|
||
|
|
self = $.ES5Object(O),
|
||
|
|
f = ctx(callbackfn, that, 3),
|
||
|
|
length = $.toLength(self.length),
|
||
|
|
index = 0,
|
||
|
|
result = IS_MAP ? Array(length) : IS_FILTER ? [] : undefined,
|
||
|
|
val,
|
||
|
|
res;
|
||
|
|
for (; length > index; index++)
|
||
|
|
if (NO_HOLES || index in self) {
|
||
|
|
val = self[index];
|
||
|
|
res = f(val, index, O);
|
||
|
|
if (TYPE) {
|
||
|
|
if (IS_MAP)
|
||
|
|
result[index] = res;
|
||
|
|
else if (res)
|
||
|
|
switch (TYPE) {
|
||
|
|
case 3:
|
||
|
|
return true;
|
||
|
|
case 5:
|
||
|
|
return val;
|
||
|
|
case 6:
|
||
|
|
return index;
|
||
|
|
case 2:
|
||
|
|
result.push(val);
|
||
|
|
}
|
||
|
|
else if (IS_EVERY)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var assertFunction = __webpack_require__(16).fn;
|
||
|
|
module.exports = function(fn, that, length) {
|
||
|
|
assertFunction(fn);
|
||
|
|
if (~length && that === undefined)
|
||
|
|
return fn;
|
||
|
|
switch (length) {
|
||
|
|
case 1:
|
||
|
|
return function(a) {
|
||
|
|
return fn.call(that, a);
|
||
|
|
};
|
||
|
|
case 2:
|
||
|
|
return function(a, b) {
|
||
|
|
return fn.call(that, a, b);
|
||
|
|
};
|
||
|
|
case 3:
|
||
|
|
return function(a, b, c) {
|
||
|
|
return fn.call(that, a, b, c);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return function() {
|
||
|
|
return fn.apply(that, arguments);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
function assert(condition, msg1, msg2) {
|
||
|
|
if (!condition)
|
||
|
|
throw TypeError(msg2 ? msg1 + msg2 : msg1);
|
||
|
|
}
|
||
|
|
assert.def = $.assertDefined;
|
||
|
|
assert.fn = function(it) {
|
||
|
|
if (!$.isFunction(it))
|
||
|
|
throw TypeError(it + ' is not a function!');
|
||
|
|
return it;
|
||
|
|
};
|
||
|
|
assert.obj = function(it) {
|
||
|
|
if (!$.isObject(it))
|
||
|
|
throw TypeError(it + ' is not an object!');
|
||
|
|
return it;
|
||
|
|
};
|
||
|
|
assert.inst = function(it, Constructor, name) {
|
||
|
|
if (!(it instanceof Constructor))
|
||
|
|
throw TypeError(name + ": use the 'new' operator!");
|
||
|
|
return it;
|
||
|
|
};
|
||
|
|
module.exports = assert;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
module.exports = function(IS_INCLUDES) {
|
||
|
|
return function($this, el, fromIndex) {
|
||
|
|
var O = $.toObject($this),
|
||
|
|
length = $.toLength(O.length),
|
||
|
|
index = $.toIndex(fromIndex, length),
|
||
|
|
value;
|
||
|
|
if (IS_INCLUDES && el != el)
|
||
|
|
while (length > index) {
|
||
|
|
value = O[index++];
|
||
|
|
if (value != value)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
for (; length > index; index++)
|
||
|
|
if (IS_INCLUDES || index in O) {
|
||
|
|
if (O[index] === el)
|
||
|
|
return IS_INCLUDES || index;
|
||
|
|
}
|
||
|
|
return !IS_INCLUDES && -1;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
module.exports = function(regExp, replace, isStatic) {
|
||
|
|
var replacer = replace === Object(replace) ? function(part) {
|
||
|
|
return replace[part];
|
||
|
|
} : replace;
|
||
|
|
return function(it) {
|
||
|
|
return String(isStatic ? it : this).replace(regExp, replacer);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
module.exports = function(exec) {
|
||
|
|
try {
|
||
|
|
exec();
|
||
|
|
return false;
|
||
|
|
} catch (e) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
setTag = __webpack_require__(12).set,
|
||
|
|
uid = __webpack_require__(6),
|
||
|
|
shared = __webpack_require__(9),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
$redef = __webpack_require__(5),
|
||
|
|
keyOf = __webpack_require__(21),
|
||
|
|
enumKeys = __webpack_require__(22),
|
||
|
|
assertObject = __webpack_require__(16).obj,
|
||
|
|
ObjectProto = Object.prototype,
|
||
|
|
DESC = $.DESC,
|
||
|
|
has = $.has,
|
||
|
|
$create = $.create,
|
||
|
|
getDesc = $.getDesc,
|
||
|
|
setDesc = $.setDesc,
|
||
|
|
desc = $.desc,
|
||
|
|
$names = __webpack_require__(23),
|
||
|
|
getNames = $names.get,
|
||
|
|
toObject = $.toObject,
|
||
|
|
$Symbol = $.g.Symbol,
|
||
|
|
setter = false,
|
||
|
|
TAG = uid('tag'),
|
||
|
|
HIDDEN = uid('hidden'),
|
||
|
|
_propertyIsEnumerable = {}.propertyIsEnumerable,
|
||
|
|
SymbolRegistry = shared('symbol-registry'),
|
||
|
|
AllSymbols = shared('symbols'),
|
||
|
|
useNative = $.isFunction($Symbol);
|
||
|
|
var setSymbolDesc = DESC ? function() {
|
||
|
|
try {
|
||
|
|
return $create(setDesc({}, HIDDEN, {get: function() {
|
||
|
|
return setDesc(this, HIDDEN, {value: false})[HIDDEN];
|
||
|
|
}}))[HIDDEN] || setDesc;
|
||
|
|
} catch (e) {
|
||
|
|
return function(it, key, D) {
|
||
|
|
var protoDesc = getDesc(ObjectProto, key);
|
||
|
|
if (protoDesc)
|
||
|
|
delete ObjectProto[key];
|
||
|
|
setDesc(it, key, D);
|
||
|
|
if (protoDesc && it !== ObjectProto)
|
||
|
|
setDesc(ObjectProto, key, protoDesc);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}() : setDesc;
|
||
|
|
function wrap(tag) {
|
||
|
|
var sym = AllSymbols[tag] = $.set($create($Symbol.prototype), TAG, tag);
|
||
|
|
DESC && setter && setSymbolDesc(ObjectProto, tag, {
|
||
|
|
configurable: true,
|
||
|
|
set: function(value) {
|
||
|
|
if (has(this, HIDDEN) && has(this[HIDDEN], tag))
|
||
|
|
this[HIDDEN][tag] = false;
|
||
|
|
setSymbolDesc(this, tag, desc(1, value));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return sym;
|
||
|
|
}
|
||
|
|
function defineProperty(it, key, D) {
|
||
|
|
if (D && has(AllSymbols, key)) {
|
||
|
|
if (!D.enumerable) {
|
||
|
|
if (!has(it, HIDDEN))
|
||
|
|
setDesc(it, HIDDEN, desc(1, {}));
|
||
|
|
it[HIDDEN][key] = true;
|
||
|
|
} else {
|
||
|
|
if (has(it, HIDDEN) && it[HIDDEN][key])
|
||
|
|
it[HIDDEN][key] = false;
|
||
|
|
D = $create(D, {enumerable: desc(0, false)});
|
||
|
|
}
|
||
|
|
return setSymbolDesc(it, key, D);
|
||
|
|
}
|
||
|
|
return setDesc(it, key, D);
|
||
|
|
}
|
||
|
|
function defineProperties(it, P) {
|
||
|
|
assertObject(it);
|
||
|
|
var keys = enumKeys(P = toObject(P)),
|
||
|
|
i = 0,
|
||
|
|
l = keys.length,
|
||
|
|
key;
|
||
|
|
while (l > i)
|
||
|
|
defineProperty(it, key = keys[i++], P[key]);
|
||
|
|
return it;
|
||
|
|
}
|
||
|
|
function create(it, P) {
|
||
|
|
return P === undefined ? $create(it) : defineProperties($create(it), P);
|
||
|
|
}
|
||
|
|
function propertyIsEnumerable(key) {
|
||
|
|
var E = _propertyIsEnumerable.call(this, key);
|
||
|
|
return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
|
||
|
|
}
|
||
|
|
function getOwnPropertyDescriptor(it, key) {
|
||
|
|
var D = getDesc(it = toObject(it), key);
|
||
|
|
if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))
|
||
|
|
D.enumerable = true;
|
||
|
|
return D;
|
||
|
|
}
|
||
|
|
function getOwnPropertyNames(it) {
|
||
|
|
var names = getNames(toObject(it)),
|
||
|
|
result = [],
|
||
|
|
i = 0,
|
||
|
|
key;
|
||
|
|
while (names.length > i)
|
||
|
|
if (!has(AllSymbols, key = names[i++]) && key != HIDDEN)
|
||
|
|
result.push(key);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function getOwnPropertySymbols(it) {
|
||
|
|
var names = getNames(toObject(it)),
|
||
|
|
result = [],
|
||
|
|
i = 0,
|
||
|
|
key;
|
||
|
|
while (names.length > i)
|
||
|
|
if (has(AllSymbols, key = names[i++]))
|
||
|
|
result.push(AllSymbols[key]);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
if (!useNative) {
|
||
|
|
$Symbol = function Symbol() {
|
||
|
|
if (this instanceof $Symbol)
|
||
|
|
throw TypeError('Symbol is not a constructor');
|
||
|
|
return wrap(uid(arguments[0]));
|
||
|
|
};
|
||
|
|
$redef($Symbol.prototype, 'toString', function() {
|
||
|
|
return this[TAG];
|
||
|
|
});
|
||
|
|
$.create = create;
|
||
|
|
$.setDesc = defineProperty;
|
||
|
|
$.getDesc = getOwnPropertyDescriptor;
|
||
|
|
$.setDescs = defineProperties;
|
||
|
|
$.getNames = $names.get = getOwnPropertyNames;
|
||
|
|
$.getSymbols = getOwnPropertySymbols;
|
||
|
|
if ($.DESC && $.FW)
|
||
|
|
$redef(ObjectProto, 'propertyIsEnumerable', propertyIsEnumerable, true);
|
||
|
|
}
|
||
|
|
var symbolStatics = {
|
||
|
|
'for': function(key) {
|
||
|
|
return has(SymbolRegistry, key += '') ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key);
|
||
|
|
},
|
||
|
|
keyFor: function keyFor(key) {
|
||
|
|
return keyOf(SymbolRegistry, key);
|
||
|
|
},
|
||
|
|
useSetter: function() {
|
||
|
|
setter = true;
|
||
|
|
},
|
||
|
|
useSimple: function() {
|
||
|
|
setter = false;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
$.each.call(('hasInstance,isConcatSpreadable,iterator,match,replace,search,' + 'species,split,toPrimitive,toStringTag,unscopables').split(','), function(it) {
|
||
|
|
var sym = __webpack_require__(8)(it);
|
||
|
|
symbolStatics[it] = useNative ? sym : wrap(sym);
|
||
|
|
});
|
||
|
|
setter = true;
|
||
|
|
$def($def.G + $def.W, {Symbol: $Symbol});
|
||
|
|
$def($def.S, 'Symbol', symbolStatics);
|
||
|
|
$def($def.S + $def.F * !useNative, 'Object', {
|
||
|
|
create: create,
|
||
|
|
defineProperty: defineProperty,
|
||
|
|
defineProperties: defineProperties,
|
||
|
|
getOwnPropertyDescriptor: getOwnPropertyDescriptor,
|
||
|
|
getOwnPropertyNames: getOwnPropertyNames,
|
||
|
|
getOwnPropertySymbols: getOwnPropertySymbols
|
||
|
|
});
|
||
|
|
setTag($Symbol, 'Symbol');
|
||
|
|
setTag(Math, 'Math', true);
|
||
|
|
setTag($.g.JSON, 'JSON', true);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
module.exports = function(object, el) {
|
||
|
|
var O = $.toObject(object),
|
||
|
|
keys = $.getKeys(O),
|
||
|
|
length = keys.length,
|
||
|
|
index = 0,
|
||
|
|
key;
|
||
|
|
while (length > index)
|
||
|
|
if (O[key = keys[index++]] === el)
|
||
|
|
return key;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
module.exports = function(it) {
|
||
|
|
var keys = $.getKeys(it),
|
||
|
|
getDesc = $.getDesc,
|
||
|
|
getSymbols = $.getSymbols;
|
||
|
|
if (getSymbols)
|
||
|
|
$.each.call(getSymbols(it), function(key) {
|
||
|
|
if (getDesc(it, key).enumerable)
|
||
|
|
keys.push(key);
|
||
|
|
});
|
||
|
|
return keys;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
toString = {}.toString,
|
||
|
|
getNames = $.getNames;
|
||
|
|
var windowNames = typeof window == 'object' && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
|
||
|
|
function getWindowNames(it) {
|
||
|
|
try {
|
||
|
|
return getNames(it);
|
||
|
|
} catch (e) {
|
||
|
|
return windowNames.slice();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
module.exports.get = function getOwnPropertyNames(it) {
|
||
|
|
if (windowNames && toString.call(it) == '[object Window]')
|
||
|
|
return getWindowNames(it);
|
||
|
|
return getNames($.toObject(it));
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'Object', {assign: __webpack_require__(25)});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
enumKeys = __webpack_require__(22);
|
||
|
|
module.exports = Object.assign || function assign(target, source) {
|
||
|
|
var T = Object($.assertDefined(target)),
|
||
|
|
l = arguments.length,
|
||
|
|
i = 1;
|
||
|
|
while (l > i) {
|
||
|
|
var S = $.ES5Object(arguments[i++]),
|
||
|
|
keys = enumKeys(S),
|
||
|
|
length = keys.length,
|
||
|
|
j = 0,
|
||
|
|
key;
|
||
|
|
while (length > j)
|
||
|
|
T[key = keys[j++]] = S[key];
|
||
|
|
}
|
||
|
|
return T;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'Object', {is: __webpack_require__(27)});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
module.exports = Object.is || function is(x, y) {
|
||
|
|
return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'Object', {setPrototypeOf: __webpack_require__(29).set});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
assert = __webpack_require__(16);
|
||
|
|
function check(O, proto) {
|
||
|
|
assert.obj(O);
|
||
|
|
assert(proto === null || $.isObject(proto), proto, ": can't set as prototype!");
|
||
|
|
}
|
||
|
|
module.exports = {
|
||
|
|
set: Object.setPrototypeOf || ('__proto__' in {} ? function(buggy, set) {
|
||
|
|
try {
|
||
|
|
set = __webpack_require__(15)(Function.call, $.getDesc(Object.prototype, '__proto__').set, 2);
|
||
|
|
set({}, []);
|
||
|
|
} catch (e) {
|
||
|
|
buggy = true;
|
||
|
|
}
|
||
|
|
return function setPrototypeOf(O, proto) {
|
||
|
|
check(O, proto);
|
||
|
|
if (buggy)
|
||
|
|
O.__proto__ = proto;
|
||
|
|
else
|
||
|
|
set(O, proto);
|
||
|
|
return O;
|
||
|
|
};
|
||
|
|
}() : undefined),
|
||
|
|
check: check
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var cof = __webpack_require__(12),
|
||
|
|
tmp = {};
|
||
|
|
tmp[__webpack_require__(8)('toStringTag')] = 'z';
|
||
|
|
if (__webpack_require__(2).FW && cof(tmp) != 'z') {
|
||
|
|
__webpack_require__(5)(Object.prototype, 'toString', function toString() {
|
||
|
|
return '[object ' + cof.classof(this) + ']';
|
||
|
|
}, true);
|
||
|
|
}
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
isObject = $.isObject,
|
||
|
|
toObject = $.toObject;
|
||
|
|
$.each.call(('freeze,seal,preventExtensions,isFrozen,isSealed,isExtensible,' + 'getOwnPropertyDescriptor,getPrototypeOf,keys,getOwnPropertyNames').split(','), function(KEY, ID) {
|
||
|
|
var fn = ($.core.Object || {})[KEY] || Object[KEY],
|
||
|
|
forced = 0,
|
||
|
|
method = {};
|
||
|
|
method[KEY] = ID == 0 ? function freeze(it) {
|
||
|
|
return isObject(it) ? fn(it) : it;
|
||
|
|
} : ID == 1 ? function seal(it) {
|
||
|
|
return isObject(it) ? fn(it) : it;
|
||
|
|
} : ID == 2 ? function preventExtensions(it) {
|
||
|
|
return isObject(it) ? fn(it) : it;
|
||
|
|
} : ID == 3 ? function isFrozen(it) {
|
||
|
|
return isObject(it) ? fn(it) : true;
|
||
|
|
} : ID == 4 ? function isSealed(it) {
|
||
|
|
return isObject(it) ? fn(it) : true;
|
||
|
|
} : ID == 5 ? function isExtensible(it) {
|
||
|
|
return isObject(it) ? fn(it) : false;
|
||
|
|
} : ID == 6 ? function getOwnPropertyDescriptor(it, key) {
|
||
|
|
return fn(toObject(it), key);
|
||
|
|
} : ID == 7 ? function getPrototypeOf(it) {
|
||
|
|
return fn(Object($.assertDefined(it)));
|
||
|
|
} : ID == 8 ? function keys(it) {
|
||
|
|
return fn(toObject(it));
|
||
|
|
} : __webpack_require__(23).get;
|
||
|
|
try {
|
||
|
|
fn('z');
|
||
|
|
} catch (e) {
|
||
|
|
forced = 1;
|
||
|
|
}
|
||
|
|
$def($def.S + $def.F * forced, 'Object', method);
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
NAME = 'name',
|
||
|
|
setDesc = $.setDesc,
|
||
|
|
FunctionProto = Function.prototype;
|
||
|
|
NAME in FunctionProto || $.FW && $.DESC && setDesc(FunctionProto, NAME, {
|
||
|
|
configurable: true,
|
||
|
|
get: function() {
|
||
|
|
var match = String(this).match(/^\s*function ([^ (]*)/),
|
||
|
|
name = match ? match[1] : '';
|
||
|
|
$.has(this, NAME) || setDesc(this, NAME, $.desc(5, name));
|
||
|
|
return name;
|
||
|
|
},
|
||
|
|
set: function(value) {
|
||
|
|
$.has(this, NAME) || setDesc(this, NAME, $.desc(0, value));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
HAS_INSTANCE = __webpack_require__(8)('hasInstance'),
|
||
|
|
FunctionProto = Function.prototype;
|
||
|
|
if (!(HAS_INSTANCE in FunctionProto))
|
||
|
|
$.setDesc(FunctionProto, HAS_INSTANCE, {value: function(O) {
|
||
|
|
if (!$.isFunction(this) || !$.isObject(O))
|
||
|
|
return false;
|
||
|
|
if (!$.isObject(this.prototype))
|
||
|
|
return O instanceof this;
|
||
|
|
while (O = $.getProto(O))
|
||
|
|
if (this.prototype === O)
|
||
|
|
return true;
|
||
|
|
return false;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
isObject = $.isObject,
|
||
|
|
isFunction = $.isFunction,
|
||
|
|
NUMBER = 'Number',
|
||
|
|
$Number = $.g[NUMBER],
|
||
|
|
Base = $Number,
|
||
|
|
proto = $Number.prototype;
|
||
|
|
function toPrimitive(it) {
|
||
|
|
var fn,
|
||
|
|
val;
|
||
|
|
if (isFunction(fn = it.valueOf) && !isObject(val = fn.call(it)))
|
||
|
|
return val;
|
||
|
|
if (isFunction(fn = it.toString) && !isObject(val = fn.call(it)))
|
||
|
|
return val;
|
||
|
|
throw TypeError("Can't convert object to number");
|
||
|
|
}
|
||
|
|
function toNumber(it) {
|
||
|
|
if (isObject(it))
|
||
|
|
it = toPrimitive(it);
|
||
|
|
if (typeof it == 'string' && it.length > 2 && it.charCodeAt(0) == 48) {
|
||
|
|
var binary = false;
|
||
|
|
switch (it.charCodeAt(1)) {
|
||
|
|
case 66:
|
||
|
|
case 98:
|
||
|
|
binary = true;
|
||
|
|
case 79:
|
||
|
|
case 111:
|
||
|
|
return parseInt(it.slice(2), binary ? 2 : 8);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return +it;
|
||
|
|
}
|
||
|
|
if ($.FW && !($Number('0o1') && $Number('0b1'))) {
|
||
|
|
$Number = function Number(it) {
|
||
|
|
return this instanceof $Number ? new Base(toNumber(it)) : toNumber(it);
|
||
|
|
};
|
||
|
|
$.each.call($.DESC ? $.getNames(Base) : ('MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger').split(','), function(key) {
|
||
|
|
if ($.has(Base, key) && !$.has($Number, key)) {
|
||
|
|
$.setDesc($Number, key, $.getDesc(Base, key));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
$Number.prototype = proto;
|
||
|
|
proto.constructor = $Number;
|
||
|
|
__webpack_require__(5)($.g, NUMBER, $Number);
|
||
|
|
}
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
abs = Math.abs,
|
||
|
|
floor = Math.floor,
|
||
|
|
_isFinite = $.g.isFinite,
|
||
|
|
MAX_SAFE_INTEGER = 0x1fffffffffffff;
|
||
|
|
function isInteger(it) {
|
||
|
|
return !$.isObject(it) && _isFinite(it) && floor(it) === it;
|
||
|
|
}
|
||
|
|
$def($def.S, 'Number', {
|
||
|
|
EPSILON: Math.pow(2, -52),
|
||
|
|
isFinite: function isFinite(it) {
|
||
|
|
return typeof it == 'number' && _isFinite(it);
|
||
|
|
},
|
||
|
|
isInteger: isInteger,
|
||
|
|
isNaN: function isNaN(number) {
|
||
|
|
return number != number;
|
||
|
|
},
|
||
|
|
isSafeInteger: function isSafeInteger(number) {
|
||
|
|
return isInteger(number) && abs(number) <= MAX_SAFE_INTEGER;
|
||
|
|
},
|
||
|
|
MAX_SAFE_INTEGER: MAX_SAFE_INTEGER,
|
||
|
|
MIN_SAFE_INTEGER: -MAX_SAFE_INTEGER,
|
||
|
|
parseFloat: parseFloat,
|
||
|
|
parseInt: parseInt
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var Infinity = 1 / 0,
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
E = Math.E,
|
||
|
|
pow = Math.pow,
|
||
|
|
abs = Math.abs,
|
||
|
|
exp = Math.exp,
|
||
|
|
log = Math.log,
|
||
|
|
sqrt = Math.sqrt,
|
||
|
|
ceil = Math.ceil,
|
||
|
|
floor = Math.floor,
|
||
|
|
EPSILON = pow(2, -52),
|
||
|
|
EPSILON32 = pow(2, -23),
|
||
|
|
MAX32 = pow(2, 127) * (2 - EPSILON32),
|
||
|
|
MIN32 = pow(2, -126);
|
||
|
|
function roundTiesToEven(n) {
|
||
|
|
return n + 1 / EPSILON - 1 / EPSILON;
|
||
|
|
}
|
||
|
|
function sign(x) {
|
||
|
|
return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
|
||
|
|
}
|
||
|
|
function asinh(x) {
|
||
|
|
return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1));
|
||
|
|
}
|
||
|
|
function expm1(x) {
|
||
|
|
return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : exp(x) - 1;
|
||
|
|
}
|
||
|
|
$def($def.S, 'Math', {
|
||
|
|
acosh: function acosh(x) {
|
||
|
|
return (x = +x) < 1 ? NaN : isFinite(x) ? log(x / E + sqrt(x + 1) * sqrt(x - 1) / E) + 1 : x;
|
||
|
|
},
|
||
|
|
asinh: asinh,
|
||
|
|
atanh: function atanh(x) {
|
||
|
|
return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2;
|
||
|
|
},
|
||
|
|
cbrt: function cbrt(x) {
|
||
|
|
return sign(x = +x) * pow(abs(x), 1 / 3);
|
||
|
|
},
|
||
|
|
clz32: function clz32(x) {
|
||
|
|
return (x >>>= 0) ? 31 - floor(log(x + 0.5) * Math.LOG2E) : 32;
|
||
|
|
},
|
||
|
|
cosh: function cosh(x) {
|
||
|
|
return (exp(x = +x) + exp(-x)) / 2;
|
||
|
|
},
|
||
|
|
expm1: expm1,
|
||
|
|
fround: function fround(x) {
|
||
|
|
var $abs = abs(x),
|
||
|
|
$sign = sign(x),
|
||
|
|
a,
|
||
|
|
result;
|
||
|
|
if ($abs < MIN32)
|
||
|
|
return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
|
||
|
|
a = (1 + EPSILON32 / EPSILON) * $abs;
|
||
|
|
result = a - (a - $abs);
|
||
|
|
if (result > MAX32 || result != result)
|
||
|
|
return $sign * Infinity;
|
||
|
|
return $sign * result;
|
||
|
|
},
|
||
|
|
hypot: function hypot(value1, value2) {
|
||
|
|
var sum = 0,
|
||
|
|
i = 0,
|
||
|
|
len = arguments.length,
|
||
|
|
larg = 0,
|
||
|
|
arg,
|
||
|
|
div;
|
||
|
|
while (i < len) {
|
||
|
|
arg = abs(arguments[i++]);
|
||
|
|
if (larg < arg) {
|
||
|
|
div = larg / arg;
|
||
|
|
sum = sum * div * div + 1;
|
||
|
|
larg = arg;
|
||
|
|
} else if (arg > 0) {
|
||
|
|
div = arg / larg;
|
||
|
|
sum += div * div;
|
||
|
|
} else
|
||
|
|
sum += arg;
|
||
|
|
}
|
||
|
|
return larg === Infinity ? Infinity : larg * sqrt(sum);
|
||
|
|
},
|
||
|
|
imul: function imul(x, y) {
|
||
|
|
var UInt16 = 0xffff,
|
||
|
|
xn = +x,
|
||
|
|
yn = +y,
|
||
|
|
xl = UInt16 & xn,
|
||
|
|
yl = UInt16 & yn;
|
||
|
|
return 0 | xl * yl + ((UInt16 & xn >>> 16) * yl + xl * (UInt16 & yn >>> 16) << 16 >>> 0);
|
||
|
|
},
|
||
|
|
log1p: function log1p(x) {
|
||
|
|
return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : log(1 + x);
|
||
|
|
},
|
||
|
|
log10: function log10(x) {
|
||
|
|
return log(x) / Math.LN10;
|
||
|
|
},
|
||
|
|
log2: function log2(x) {
|
||
|
|
return log(x) / Math.LN2;
|
||
|
|
},
|
||
|
|
sign: sign,
|
||
|
|
sinh: function sinh(x) {
|
||
|
|
return abs(x = +x) < 1 ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2);
|
||
|
|
},
|
||
|
|
tanh: function tanh(x) {
|
||
|
|
var a = expm1(x = +x),
|
||
|
|
b = expm1(-x);
|
||
|
|
return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
|
||
|
|
},
|
||
|
|
trunc: function trunc(it) {
|
||
|
|
return (it > 0 ? floor : ceil)(it);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
toIndex = __webpack_require__(2).toIndex,
|
||
|
|
fromCharCode = String.fromCharCode,
|
||
|
|
$fromCodePoint = String.fromCodePoint;
|
||
|
|
$def($def.S + $def.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {fromCodePoint: function fromCodePoint(x) {
|
||
|
|
var res = [],
|
||
|
|
len = arguments.length,
|
||
|
|
i = 0,
|
||
|
|
code;
|
||
|
|
while (len > i) {
|
||
|
|
code = +arguments[i++];
|
||
|
|
if (toIndex(code, 0x10ffff) !== code)
|
||
|
|
throw RangeError(code + ' is not a valid code point');
|
||
|
|
res.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00));
|
||
|
|
}
|
||
|
|
return res.join('');
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'String', {raw: function raw(callSite) {
|
||
|
|
var tpl = $.toObject(callSite.raw),
|
||
|
|
len = $.toLength(tpl.length),
|
||
|
|
sln = arguments.length,
|
||
|
|
res = [],
|
||
|
|
i = 0;
|
||
|
|
while (len > i) {
|
||
|
|
res.push(String(tpl[i++]));
|
||
|
|
if (i < sln)
|
||
|
|
res.push(String(arguments[i]));
|
||
|
|
}
|
||
|
|
return res.join('');
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var set = __webpack_require__(2).set,
|
||
|
|
$at = __webpack_require__(40)(true),
|
||
|
|
ITER = __webpack_require__(6).safe('iter'),
|
||
|
|
$iter = __webpack_require__(41),
|
||
|
|
step = $iter.step;
|
||
|
|
__webpack_require__(42)(String, 'String', function(iterated) {
|
||
|
|
set(this, ITER, {
|
||
|
|
o: String(iterated),
|
||
|
|
i: 0
|
||
|
|
});
|
||
|
|
}, function() {
|
||
|
|
var iter = this[ITER],
|
||
|
|
O = iter.o,
|
||
|
|
index = iter.i,
|
||
|
|
point;
|
||
|
|
if (index >= O.length)
|
||
|
|
return step(1);
|
||
|
|
point = $at(O, index);
|
||
|
|
iter.i += point.length;
|
||
|
|
return step(0, point);
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
module.exports = function(TO_STRING) {
|
||
|
|
return function(that, pos) {
|
||
|
|
var s = String($.assertDefined(that)),
|
||
|
|
i = $.toInteger(pos),
|
||
|
|
l = s.length,
|
||
|
|
a,
|
||
|
|
b;
|
||
|
|
if (i < 0 || i >= l)
|
||
|
|
return TO_STRING ? '' : undefined;
|
||
|
|
a = s.charCodeAt(i);
|
||
|
|
return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
classof = cof.classof,
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
assertObject = assert.obj,
|
||
|
|
SYMBOL_ITERATOR = __webpack_require__(8)('iterator'),
|
||
|
|
FF_ITERATOR = '@@iterator',
|
||
|
|
Iterators = __webpack_require__(9)('iterators'),
|
||
|
|
IteratorPrototype = {};
|
||
|
|
setIterator(IteratorPrototype, $.that);
|
||
|
|
function setIterator(O, value) {
|
||
|
|
$.hide(O, SYMBOL_ITERATOR, value);
|
||
|
|
if (FF_ITERATOR in [])
|
||
|
|
$.hide(O, FF_ITERATOR, value);
|
||
|
|
}
|
||
|
|
module.exports = {
|
||
|
|
BUGGY: 'keys' in [] && !('next' in [].keys()),
|
||
|
|
Iterators: Iterators,
|
||
|
|
step: function(done, value) {
|
||
|
|
return {
|
||
|
|
value: value,
|
||
|
|
done: !!done
|
||
|
|
};
|
||
|
|
},
|
||
|
|
is: function(it) {
|
||
|
|
var O = Object(it),
|
||
|
|
Symbol = $.g.Symbol;
|
||
|
|
return (Symbol && Symbol.iterator || FF_ITERATOR) in O || SYMBOL_ITERATOR in O || $.has(Iterators, classof(O));
|
||
|
|
},
|
||
|
|
get: function(it) {
|
||
|
|
var Symbol = $.g.Symbol,
|
||
|
|
getIter;
|
||
|
|
if (it != undefined) {
|
||
|
|
getIter = it[Symbol && Symbol.iterator || FF_ITERATOR] || it[SYMBOL_ITERATOR] || Iterators[classof(it)];
|
||
|
|
}
|
||
|
|
assert($.isFunction(getIter), it, ' is not iterable!');
|
||
|
|
return assertObject(getIter.call(it));
|
||
|
|
},
|
||
|
|
set: setIterator,
|
||
|
|
create: function(Constructor, NAME, next, proto) {
|
||
|
|
Constructor.prototype = $.create(proto || IteratorPrototype, {next: $.desc(1, next)});
|
||
|
|
cof.set(Constructor, NAME + ' Iterator');
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$redef = __webpack_require__(5),
|
||
|
|
$ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$iter = __webpack_require__(41),
|
||
|
|
SYMBOL_ITERATOR = __webpack_require__(8)('iterator'),
|
||
|
|
FF_ITERATOR = '@@iterator',
|
||
|
|
KEYS = 'keys',
|
||
|
|
VALUES = 'values',
|
||
|
|
Iterators = $iter.Iterators;
|
||
|
|
module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE) {
|
||
|
|
$iter.create(Constructor, NAME, next);
|
||
|
|
function createMethod(kind) {
|
||
|
|
function $$(that) {
|
||
|
|
return new Constructor(that, kind);
|
||
|
|
}
|
||
|
|
switch (kind) {
|
||
|
|
case KEYS:
|
||
|
|
return function keys() {
|
||
|
|
return $$(this);
|
||
|
|
};
|
||
|
|
case VALUES:
|
||
|
|
return function values() {
|
||
|
|
return $$(this);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return function entries() {
|
||
|
|
return $$(this);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
var TAG = NAME + ' Iterator',
|
||
|
|
proto = Base.prototype,
|
||
|
|
_native = proto[SYMBOL_ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT],
|
||
|
|
_default = _native || createMethod(DEFAULT),
|
||
|
|
methods,
|
||
|
|
key;
|
||
|
|
if (_native) {
|
||
|
|
var IteratorPrototype = $.getProto(_default.call(new Base));
|
||
|
|
cof.set(IteratorPrototype, TAG, true);
|
||
|
|
if ($.FW && $.has(proto, FF_ITERATOR))
|
||
|
|
$iter.set(IteratorPrototype, $.that);
|
||
|
|
}
|
||
|
|
if ($.FW || FORCE)
|
||
|
|
$iter.set(proto, _default);
|
||
|
|
Iterators[NAME] = _default;
|
||
|
|
Iterators[TAG] = $.that;
|
||
|
|
if (DEFAULT) {
|
||
|
|
methods = {
|
||
|
|
keys: IS_SET ? _default : createMethod(KEYS),
|
||
|
|
values: DEFAULT == VALUES ? _default : createMethod(VALUES),
|
||
|
|
entries: DEFAULT != VALUES ? _default : createMethod('entries')
|
||
|
|
};
|
||
|
|
if (FORCE)
|
||
|
|
for (key in methods) {
|
||
|
|
if (!(key in proto))
|
||
|
|
$redef(proto, key, methods[key]);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
$def($def.P + $def.F * $iter.BUGGY, NAME, methods);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$at = __webpack_require__(40)(false);
|
||
|
|
$def($def.P, 'String', {codePointAt: function codePointAt(pos) {
|
||
|
|
return $at(this, pos);
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
toLength = $.toLength;
|
||
|
|
$def($def.P + $def.F * !__webpack_require__(19)(function() {
|
||
|
|
'q'.endsWith(/./);
|
||
|
|
}), 'String', {endsWith: function endsWith(searchString) {
|
||
|
|
if (cof(searchString) == 'RegExp')
|
||
|
|
throw TypeError();
|
||
|
|
var that = String($.assertDefined(this)),
|
||
|
|
endPosition = arguments[1],
|
||
|
|
len = toLength(that.length),
|
||
|
|
end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
|
||
|
|
searchString += '';
|
||
|
|
return that.slice(end - searchString.length, end) === searchString;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$def = __webpack_require__(4);
|
||
|
|
$def($def.P, 'String', {includes: function includes(searchString) {
|
||
|
|
if (cof(searchString) == 'RegExp')
|
||
|
|
throw TypeError();
|
||
|
|
return !!~String($.assertDefined(this)).indexOf(searchString, arguments[1]);
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.P, 'String', {repeat: __webpack_require__(47)});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2);
|
||
|
|
module.exports = function repeat(count) {
|
||
|
|
var str = String($.assertDefined(this)),
|
||
|
|
res = '',
|
||
|
|
n = $.toInteger(count);
|
||
|
|
if (n < 0 || n == Infinity)
|
||
|
|
throw RangeError("Count can't be negative");
|
||
|
|
for (; n > 0; (n >>>= 1) && (str += str))
|
||
|
|
if (n & 1)
|
||
|
|
res += str;
|
||
|
|
return res;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$def = __webpack_require__(4);
|
||
|
|
$def($def.P + $def.F * !__webpack_require__(19)(function() {
|
||
|
|
'q'.startsWith(/./);
|
||
|
|
}), 'String', {startsWith: function startsWith(searchString) {
|
||
|
|
if (cof(searchString) == 'RegExp')
|
||
|
|
throw TypeError();
|
||
|
|
var that = String($.assertDefined(this)),
|
||
|
|
index = $.toLength(Math.min(arguments[1], that.length));
|
||
|
|
searchString += '';
|
||
|
|
return that.slice(index, index + searchString.length) === searchString;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
ctx = __webpack_require__(15),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
$iter = __webpack_require__(41),
|
||
|
|
call = __webpack_require__(50);
|
||
|
|
$def($def.S + $def.F * !__webpack_require__(51)(function(iter) {
|
||
|
|
Array.from(iter);
|
||
|
|
}), 'Array', {from: function from(arrayLike) {
|
||
|
|
var O = Object($.assertDefined(arrayLike)),
|
||
|
|
mapfn = arguments[1],
|
||
|
|
mapping = mapfn !== undefined,
|
||
|
|
f = mapping ? ctx(mapfn, arguments[2], 2) : undefined,
|
||
|
|
index = 0,
|
||
|
|
length,
|
||
|
|
result,
|
||
|
|
step,
|
||
|
|
iterator;
|
||
|
|
if ($iter.is(O)) {
|
||
|
|
iterator = $iter.get(O);
|
||
|
|
result = new (typeof this == 'function' ? this : Array);
|
||
|
|
for (; !(step = iterator.next()).done; index++) {
|
||
|
|
result[index] = mapping ? call(iterator, f, [step.value, index], true) : step.value;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
result = new (typeof this == 'function' ? this : Array)(length = $.toLength(O.length));
|
||
|
|
for (; length > index; index++) {
|
||
|
|
result[index] = mapping ? f(O[index], index) : O[index];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
result.length = index;
|
||
|
|
return result;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var assertObject = __webpack_require__(16).obj;
|
||
|
|
function close(iterator) {
|
||
|
|
var ret = iterator['return'];
|
||
|
|
if (ret !== undefined)
|
||
|
|
assertObject(ret.call(iterator));
|
||
|
|
}
|
||
|
|
function call(iterator, fn, value, entries) {
|
||
|
|
try {
|
||
|
|
return entries ? fn(assertObject(value)[0], value[1]) : fn(value);
|
||
|
|
} catch (e) {
|
||
|
|
close(iterator);
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
call.close = close;
|
||
|
|
module.exports = call;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var SYMBOL_ITERATOR = __webpack_require__(8)('iterator'),
|
||
|
|
SAFE_CLOSING = false;
|
||
|
|
try {
|
||
|
|
var riter = [7][SYMBOL_ITERATOR]();
|
||
|
|
riter['return'] = function() {
|
||
|
|
SAFE_CLOSING = true;
|
||
|
|
};
|
||
|
|
Array.from(riter, function() {
|
||
|
|
throw 2;
|
||
|
|
});
|
||
|
|
} catch (e) {}
|
||
|
|
module.exports = function(exec) {
|
||
|
|
if (!SAFE_CLOSING)
|
||
|
|
return false;
|
||
|
|
var safe = false;
|
||
|
|
try {
|
||
|
|
var arr = [7],
|
||
|
|
iter = arr[SYMBOL_ITERATOR]();
|
||
|
|
iter.next = function() {
|
||
|
|
safe = true;
|
||
|
|
};
|
||
|
|
arr[SYMBOL_ITERATOR] = function() {
|
||
|
|
return iter;
|
||
|
|
};
|
||
|
|
exec(arr);
|
||
|
|
} catch (e) {}
|
||
|
|
return safe;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'Array', {of: function of() {
|
||
|
|
var index = 0,
|
||
|
|
length = arguments.length,
|
||
|
|
result = new (typeof this == 'function' ? this : Array)(length);
|
||
|
|
while (length > index)
|
||
|
|
result[index] = arguments[index++];
|
||
|
|
result.length = length;
|
||
|
|
return result;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
setUnscope = __webpack_require__(7),
|
||
|
|
ITER = __webpack_require__(6).safe('iter'),
|
||
|
|
$iter = __webpack_require__(41),
|
||
|
|
step = $iter.step,
|
||
|
|
Iterators = $iter.Iterators;
|
||
|
|
__webpack_require__(42)(Array, 'Array', function(iterated, kind) {
|
||
|
|
$.set(this, ITER, {
|
||
|
|
o: $.toObject(iterated),
|
||
|
|
i: 0,
|
||
|
|
k: kind
|
||
|
|
});
|
||
|
|
}, function() {
|
||
|
|
var iter = this[ITER],
|
||
|
|
O = iter.o,
|
||
|
|
kind = iter.k,
|
||
|
|
index = iter.i++;
|
||
|
|
if (!O || index >= O.length) {
|
||
|
|
iter.o = undefined;
|
||
|
|
return step(1);
|
||
|
|
}
|
||
|
|
if (kind == 'keys')
|
||
|
|
return step(0, index);
|
||
|
|
if (kind == 'values')
|
||
|
|
return step(0, O[index]);
|
||
|
|
return step(0, [index, O[index]]);
|
||
|
|
}, 'values');
|
||
|
|
Iterators.Arguments = Iterators.Array;
|
||
|
|
setUnscope('keys');
|
||
|
|
setUnscope('values');
|
||
|
|
setUnscope('entries');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
__webpack_require__(55)(Array);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
SPECIES = __webpack_require__(8)('species');
|
||
|
|
module.exports = function(C) {
|
||
|
|
if ($.DESC && !(SPECIES in C))
|
||
|
|
$.setDesc(C, SPECIES, {
|
||
|
|
configurable: true,
|
||
|
|
get: $.that
|
||
|
|
});
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
toIndex = $.toIndex;
|
||
|
|
$def($def.P, 'Array', {fill: function fill(value) {
|
||
|
|
var O = Object($.assertDefined(this)),
|
||
|
|
length = $.toLength(O.length),
|
||
|
|
index = toIndex(arguments[1], length),
|
||
|
|
end = arguments[2],
|
||
|
|
endPos = end === undefined ? length : toIndex(end, length);
|
||
|
|
while (endPos > index)
|
||
|
|
O[index++] = value;
|
||
|
|
return O;
|
||
|
|
}});
|
||
|
|
__webpack_require__(7)('fill');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var KEY = 'find',
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
forced = true,
|
||
|
|
$find = __webpack_require__(14)(5);
|
||
|
|
if (KEY in [])
|
||
|
|
Array(1)[KEY](function() {
|
||
|
|
forced = false;
|
||
|
|
});
|
||
|
|
$def($def.P + $def.F * forced, 'Array', {find: function find(callbackfn) {
|
||
|
|
return $find(this, callbackfn, arguments[1]);
|
||
|
|
}});
|
||
|
|
__webpack_require__(7)(KEY);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var KEY = 'findIndex',
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
forced = true,
|
||
|
|
$find = __webpack_require__(14)(6);
|
||
|
|
if (KEY in [])
|
||
|
|
Array(1)[KEY](function() {
|
||
|
|
forced = false;
|
||
|
|
});
|
||
|
|
$def($def.P + $def.F * forced, 'Array', {findIndex: function findIndex(callbackfn) {
|
||
|
|
return $find(this, callbackfn, arguments[1]);
|
||
|
|
}});
|
||
|
|
__webpack_require__(7)(KEY);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$RegExp = $.g.RegExp,
|
||
|
|
Base = $RegExp,
|
||
|
|
proto = $RegExp.prototype,
|
||
|
|
re = /a/g,
|
||
|
|
CORRECT_NEW = new $RegExp(re) !== re,
|
||
|
|
ALLOWS_RE_WITH_FLAGS = function() {
|
||
|
|
try {
|
||
|
|
return $RegExp(re, 'i') == '/a/i';
|
||
|
|
} catch (e) {}
|
||
|
|
}();
|
||
|
|
if ($.FW && $.DESC) {
|
||
|
|
if (!CORRECT_NEW || !ALLOWS_RE_WITH_FLAGS) {
|
||
|
|
$RegExp = function RegExp(pattern, flags) {
|
||
|
|
var patternIsRegExp = cof(pattern) == 'RegExp',
|
||
|
|
flagsIsUndefined = flags === undefined;
|
||
|
|
if (!(this instanceof $RegExp) && patternIsRegExp && flagsIsUndefined)
|
||
|
|
return pattern;
|
||
|
|
return CORRECT_NEW ? new Base(patternIsRegExp && !flagsIsUndefined ? pattern.source : pattern, flags) : new Base(patternIsRegExp ? pattern.source : pattern, patternIsRegExp && flagsIsUndefined ? pattern.flags : flags);
|
||
|
|
};
|
||
|
|
$.each.call($.getNames(Base), function(key) {
|
||
|
|
key in $RegExp || $.setDesc($RegExp, key, {
|
||
|
|
configurable: true,
|
||
|
|
get: function() {
|
||
|
|
return Base[key];
|
||
|
|
},
|
||
|
|
set: function(it) {
|
||
|
|
Base[key] = it;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
proto.constructor = $RegExp;
|
||
|
|
$RegExp.prototype = proto;
|
||
|
|
__webpack_require__(5)($.g, 'RegExp', $RegExp);
|
||
|
|
}
|
||
|
|
if (/./g.flags != 'g')
|
||
|
|
$.setDesc(proto, 'flags', {
|
||
|
|
configurable: true,
|
||
|
|
get: __webpack_require__(18)(/^.*\/(\w*)$/, '$1')
|
||
|
|
});
|
||
|
|
}
|
||
|
|
__webpack_require__(55)($RegExp);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
ctx = __webpack_require__(15),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
forOf = __webpack_require__(61),
|
||
|
|
setProto = __webpack_require__(29).set,
|
||
|
|
same = __webpack_require__(27),
|
||
|
|
species = __webpack_require__(55),
|
||
|
|
SPECIES = __webpack_require__(8)('species'),
|
||
|
|
RECORD = __webpack_require__(6).safe('record'),
|
||
|
|
PROMISE = 'Promise',
|
||
|
|
global = $.g,
|
||
|
|
process = global.process,
|
||
|
|
isNode = cof(process) == 'process',
|
||
|
|
asap = process && process.nextTick || __webpack_require__(62).set,
|
||
|
|
P = global[PROMISE],
|
||
|
|
isFunction = $.isFunction,
|
||
|
|
isObject = $.isObject,
|
||
|
|
assertFunction = assert.fn,
|
||
|
|
assertObject = assert.obj,
|
||
|
|
Wrapper;
|
||
|
|
function testResolve(sub) {
|
||
|
|
var test = new P(function() {});
|
||
|
|
if (sub)
|
||
|
|
test.constructor = Object;
|
||
|
|
return P.resolve(test) === test;
|
||
|
|
}
|
||
|
|
var useNative = function() {
|
||
|
|
var works = false;
|
||
|
|
function P2(x) {
|
||
|
|
var self = new P(x);
|
||
|
|
setProto(self, P2.prototype);
|
||
|
|
return self;
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
works = isFunction(P) && isFunction(P.resolve) && testResolve();
|
||
|
|
setProto(P2, P);
|
||
|
|
P2.prototype = $.create(P.prototype, {constructor: {value: P2}});
|
||
|
|
if (!(P2.resolve(5).then(function() {}) instanceof P2)) {
|
||
|
|
works = false;
|
||
|
|
}
|
||
|
|
if (works && $.DESC) {
|
||
|
|
var thenableThenGotten = false;
|
||
|
|
P.resolve($.setDesc({}, 'then', {get: function() {
|
||
|
|
thenableThenGotten = true;
|
||
|
|
}}));
|
||
|
|
works = thenableThenGotten;
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
works = false;
|
||
|
|
}
|
||
|
|
return works;
|
||
|
|
}();
|
||
|
|
function isPromise(it) {
|
||
|
|
return isObject(it) && (useNative ? cof.classof(it) == 'Promise' : RECORD in it);
|
||
|
|
}
|
||
|
|
function sameConstructor(a, b) {
|
||
|
|
if (!$.FW && a === P && b === Wrapper)
|
||
|
|
return true;
|
||
|
|
return same(a, b);
|
||
|
|
}
|
||
|
|
function getConstructor(C) {
|
||
|
|
var S = assertObject(C)[SPECIES];
|
||
|
|
return S != undefined ? S : C;
|
||
|
|
}
|
||
|
|
function isThenable(it) {
|
||
|
|
var then;
|
||
|
|
if (isObject(it))
|
||
|
|
then = it.then;
|
||
|
|
return isFunction(then) ? then : false;
|
||
|
|
}
|
||
|
|
function notify(record) {
|
||
|
|
var chain = record.c;
|
||
|
|
if (chain.length)
|
||
|
|
asap.call(global, function() {
|
||
|
|
var value = record.v,
|
||
|
|
ok = record.s == 1,
|
||
|
|
i = 0;
|
||
|
|
function run(react) {
|
||
|
|
var cb = ok ? react.ok : react.fail,
|
||
|
|
ret,
|
||
|
|
then;
|
||
|
|
try {
|
||
|
|
if (cb) {
|
||
|
|
if (!ok)
|
||
|
|
record.h = true;
|
||
|
|
ret = cb === true ? value : cb(value);
|
||
|
|
if (ret === react.P) {
|
||
|
|
react.rej(TypeError('Promise-chain cycle'));
|
||
|
|
} else if (then = isThenable(ret)) {
|
||
|
|
then.call(ret, react.res, react.rej);
|
||
|
|
} else
|
||
|
|
react.res(ret);
|
||
|
|
} else
|
||
|
|
react.rej(value);
|
||
|
|
} catch (err) {
|
||
|
|
react.rej(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while (chain.length > i)
|
||
|
|
run(chain[i++]);
|
||
|
|
chain.length = 0;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function isUnhandled(promise) {
|
||
|
|
var record = promise[RECORD],
|
||
|
|
chain = record.a || record.c,
|
||
|
|
i = 0,
|
||
|
|
react;
|
||
|
|
if (record.h)
|
||
|
|
return false;
|
||
|
|
while (chain.length > i) {
|
||
|
|
react = chain[i++];
|
||
|
|
if (react.fail || !isUnhandled(react.P))
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
function $reject(value) {
|
||
|
|
var record = this,
|
||
|
|
promise;
|
||
|
|
if (record.d)
|
||
|
|
return ;
|
||
|
|
record.d = true;
|
||
|
|
record = record.r || record;
|
||
|
|
record.v = value;
|
||
|
|
record.s = 2;
|
||
|
|
record.a = record.c.slice();
|
||
|
|
setTimeout(function() {
|
||
|
|
asap.call(global, function() {
|
||
|
|
if (isUnhandled(promise = record.p)) {
|
||
|
|
if (isNode) {
|
||
|
|
process.emit('unhandledRejection', value, promise);
|
||
|
|
} else if (global.console && console.error) {
|
||
|
|
console.error('Unhandled promise rejection', value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
record.a = undefined;
|
||
|
|
});
|
||
|
|
}, 1);
|
||
|
|
notify(record);
|
||
|
|
}
|
||
|
|
function $resolve(value) {
|
||
|
|
var record = this,
|
||
|
|
then;
|
||
|
|
if (record.d)
|
||
|
|
return ;
|
||
|
|
record.d = true;
|
||
|
|
record = record.r || record;
|
||
|
|
try {
|
||
|
|
if (then = isThenable(value)) {
|
||
|
|
asap.call(global, function() {
|
||
|
|
var wrapper = {
|
||
|
|
r: record,
|
||
|
|
d: false
|
||
|
|
};
|
||
|
|
try {
|
||
|
|
then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
|
||
|
|
} catch (e) {
|
||
|
|
$reject.call(wrapper, e);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
record.v = value;
|
||
|
|
record.s = 1;
|
||
|
|
notify(record);
|
||
|
|
}
|
||
|
|
} catch (e) {
|
||
|
|
$reject.call({
|
||
|
|
r: record,
|
||
|
|
d: false
|
||
|
|
}, e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!useNative) {
|
||
|
|
P = function Promise(executor) {
|
||
|
|
assertFunction(executor);
|
||
|
|
var record = {
|
||
|
|
p: assert.inst(this, P, PROMISE),
|
||
|
|
c: [],
|
||
|
|
a: undefined,
|
||
|
|
s: 0,
|
||
|
|
d: false,
|
||
|
|
v: undefined,
|
||
|
|
h: false
|
||
|
|
};
|
||
|
|
$.hide(this, RECORD, record);
|
||
|
|
try {
|
||
|
|
executor(ctx($resolve, record, 1), ctx($reject, record, 1));
|
||
|
|
} catch (err) {
|
||
|
|
$reject.call(record, err);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
__webpack_require__(63)(P.prototype, {
|
||
|
|
then: function then(onFulfilled, onRejected) {
|
||
|
|
var S = assertObject(assertObject(this).constructor)[SPECIES];
|
||
|
|
var react = {
|
||
|
|
ok: isFunction(onFulfilled) ? onFulfilled : true,
|
||
|
|
fail: isFunction(onRejected) ? onRejected : false
|
||
|
|
};
|
||
|
|
var promise = react.P = new (S != undefined ? S : P)(function(res, rej) {
|
||
|
|
react.res = assertFunction(res);
|
||
|
|
react.rej = assertFunction(rej);
|
||
|
|
});
|
||
|
|
var record = this[RECORD];
|
||
|
|
record.c.push(react);
|
||
|
|
if (record.a)
|
||
|
|
record.a.push(react);
|
||
|
|
if (record.s)
|
||
|
|
notify(record);
|
||
|
|
return promise;
|
||
|
|
},
|
||
|
|
'catch': function(onRejected) {
|
||
|
|
return this.then(undefined, onRejected);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
$def($def.G + $def.W + $def.F * !useNative, {Promise: P});
|
||
|
|
cof.set(P, PROMISE);
|
||
|
|
species(P);
|
||
|
|
species(Wrapper = $.core[PROMISE]);
|
||
|
|
$def($def.S + $def.F * !useNative, PROMISE, {reject: function reject(r) {
|
||
|
|
return new (getConstructor(this))(function(res, rej) {
|
||
|
|
rej(r);
|
||
|
|
});
|
||
|
|
}});
|
||
|
|
$def($def.S + $def.F * (!useNative || testResolve(true)), PROMISE, {resolve: function resolve(x) {
|
||
|
|
return isPromise(x) && sameConstructor(x.constructor, this) ? x : new this(function(res) {
|
||
|
|
res(x);
|
||
|
|
});
|
||
|
|
}});
|
||
|
|
$def($def.S + $def.F * !(useNative && __webpack_require__(51)(function(iter) {
|
||
|
|
P.all(iter)['catch'](function() {});
|
||
|
|
})), PROMISE, {
|
||
|
|
all: function all(iterable) {
|
||
|
|
var C = getConstructor(this),
|
||
|
|
values = [];
|
||
|
|
return new C(function(res, rej) {
|
||
|
|
forOf(iterable, false, values.push, values);
|
||
|
|
var remaining = values.length,
|
||
|
|
results = Array(remaining);
|
||
|
|
if (remaining)
|
||
|
|
$.each.call(values, function(promise, index) {
|
||
|
|
C.resolve(promise).then(function(value) {
|
||
|
|
results[index] = value;
|
||
|
|
--remaining || res(results);
|
||
|
|
}, rej);
|
||
|
|
});
|
||
|
|
else
|
||
|
|
res(results);
|
||
|
|
});
|
||
|
|
},
|
||
|
|
race: function race(iterable) {
|
||
|
|
var C = getConstructor(this);
|
||
|
|
return new C(function(res, rej) {
|
||
|
|
forOf(iterable, false, function(promise) {
|
||
|
|
C.resolve(promise).then(res, rej);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var ctx = __webpack_require__(15),
|
||
|
|
get = __webpack_require__(41).get,
|
||
|
|
call = __webpack_require__(50);
|
||
|
|
module.exports = function(iterable, entries, fn, that) {
|
||
|
|
var iterator = get(iterable),
|
||
|
|
f = ctx(fn, that, entries ? 2 : 1),
|
||
|
|
step;
|
||
|
|
while (!(step = iterator.next()).done) {
|
||
|
|
if (call(iterator, f, step.value, entries) === false) {
|
||
|
|
return call.close(iterator);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
ctx = __webpack_require__(15),
|
||
|
|
cof = __webpack_require__(12),
|
||
|
|
invoke = __webpack_require__(13),
|
||
|
|
cel = __webpack_require__(11),
|
||
|
|
global = $.g,
|
||
|
|
isFunction = $.isFunction,
|
||
|
|
html = $.html,
|
||
|
|
process = global.process,
|
||
|
|
setTask = global.setImmediate,
|
||
|
|
clearTask = global.clearImmediate,
|
||
|
|
MessageChannel = global.MessageChannel,
|
||
|
|
counter = 0,
|
||
|
|
queue = {},
|
||
|
|
ONREADYSTATECHANGE = 'onreadystatechange',
|
||
|
|
defer,
|
||
|
|
channel,
|
||
|
|
port;
|
||
|
|
function run() {
|
||
|
|
var id = +this;
|
||
|
|
if ($.has(queue, id)) {
|
||
|
|
var fn = queue[id];
|
||
|
|
delete queue[id];
|
||
|
|
fn();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function listner(event) {
|
||
|
|
run.call(event.data);
|
||
|
|
}
|
||
|
|
if (!isFunction(setTask) || !isFunction(clearTask)) {
|
||
|
|
setTask = function(fn) {
|
||
|
|
var args = [],
|
||
|
|
i = 1;
|
||
|
|
while (arguments.length > i)
|
||
|
|
args.push(arguments[i++]);
|
||
|
|
queue[++counter] = function() {
|
||
|
|
invoke(isFunction(fn) ? fn : Function(fn), args);
|
||
|
|
};
|
||
|
|
defer(counter);
|
||
|
|
return counter;
|
||
|
|
};
|
||
|
|
clearTask = function(id) {
|
||
|
|
delete queue[id];
|
||
|
|
};
|
||
|
|
if (cof(process) == 'process') {
|
||
|
|
defer = function(id) {
|
||
|
|
process.nextTick(ctx(run, id, 1));
|
||
|
|
};
|
||
|
|
} else if (global.addEventListener && isFunction(global.postMessage) && !global.importScripts) {
|
||
|
|
defer = function(id) {
|
||
|
|
global.postMessage(id, '*');
|
||
|
|
};
|
||
|
|
global.addEventListener('message', listner, false);
|
||
|
|
} else if (isFunction(MessageChannel)) {
|
||
|
|
channel = new MessageChannel;
|
||
|
|
port = channel.port2;
|
||
|
|
channel.port1.onmessage = listner;
|
||
|
|
defer = ctx(port.postMessage, port, 1);
|
||
|
|
} else if (ONREADYSTATECHANGE in cel('script')) {
|
||
|
|
defer = function(id) {
|
||
|
|
html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function() {
|
||
|
|
html.removeChild(this);
|
||
|
|
run.call(id);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
defer = function(id) {
|
||
|
|
setTimeout(ctx(run, id, 1), 0);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
module.exports = {
|
||
|
|
set: setTask,
|
||
|
|
clear: clearTask
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $redef = __webpack_require__(5);
|
||
|
|
module.exports = function(target, src) {
|
||
|
|
for (var key in src)
|
||
|
|
$redef(target, key, src[key]);
|
||
|
|
return target;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var strong = __webpack_require__(65);
|
||
|
|
__webpack_require__(66)('Map', function(get) {
|
||
|
|
return function Map() {
|
||
|
|
return get(this, arguments[0]);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
get: function get(key) {
|
||
|
|
var entry = strong.getEntry(this, key);
|
||
|
|
return entry && entry.v;
|
||
|
|
},
|
||
|
|
set: function set(key, value) {
|
||
|
|
return strong.def(this, key === 0 ? 0 : key, value);
|
||
|
|
}
|
||
|
|
}, strong, true);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
ctx = __webpack_require__(15),
|
||
|
|
safe = __webpack_require__(6).safe,
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
forOf = __webpack_require__(61),
|
||
|
|
step = __webpack_require__(41).step,
|
||
|
|
$has = $.has,
|
||
|
|
set = $.set,
|
||
|
|
isObject = $.isObject,
|
||
|
|
hide = $.hide,
|
||
|
|
isExtensible = Object.isExtensible || isObject,
|
||
|
|
ID = safe('id'),
|
||
|
|
O1 = safe('O1'),
|
||
|
|
LAST = safe('last'),
|
||
|
|
FIRST = safe('first'),
|
||
|
|
ITER = safe('iter'),
|
||
|
|
SIZE = $.DESC ? safe('size') : 'size',
|
||
|
|
id = 0;
|
||
|
|
function fastKey(it, create) {
|
||
|
|
if (!isObject(it))
|
||
|
|
return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
|
||
|
|
if (!$has(it, ID)) {
|
||
|
|
if (!isExtensible(it))
|
||
|
|
return 'F';
|
||
|
|
if (!create)
|
||
|
|
return 'E';
|
||
|
|
hide(it, ID, ++id);
|
||
|
|
}
|
||
|
|
return 'O' + it[ID];
|
||
|
|
}
|
||
|
|
function getEntry(that, key) {
|
||
|
|
var index = fastKey(key),
|
||
|
|
entry;
|
||
|
|
if (index !== 'F')
|
||
|
|
return that[O1][index];
|
||
|
|
for (entry = that[FIRST]; entry; entry = entry.n) {
|
||
|
|
if (entry.k == key)
|
||
|
|
return entry;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
module.exports = {
|
||
|
|
getConstructor: function(wrapper, NAME, IS_MAP, ADDER) {
|
||
|
|
var C = wrapper(function(that, iterable) {
|
||
|
|
assert.inst(that, C, NAME);
|
||
|
|
set(that, O1, $.create(null));
|
||
|
|
set(that, SIZE, 0);
|
||
|
|
set(that, LAST, undefined);
|
||
|
|
set(that, FIRST, undefined);
|
||
|
|
if (iterable != undefined)
|
||
|
|
forOf(iterable, IS_MAP, that[ADDER], that);
|
||
|
|
});
|
||
|
|
__webpack_require__(63)(C.prototype, {
|
||
|
|
clear: function clear() {
|
||
|
|
for (var that = this,
|
||
|
|
data = that[O1],
|
||
|
|
entry = that[FIRST]; entry; entry = entry.n) {
|
||
|
|
entry.r = true;
|
||
|
|
if (entry.p)
|
||
|
|
entry.p = entry.p.n = undefined;
|
||
|
|
delete data[entry.i];
|
||
|
|
}
|
||
|
|
that[FIRST] = that[LAST] = undefined;
|
||
|
|
that[SIZE] = 0;
|
||
|
|
},
|
||
|
|
'delete': function(key) {
|
||
|
|
var that = this,
|
||
|
|
entry = getEntry(that, key);
|
||
|
|
if (entry) {
|
||
|
|
var next = entry.n,
|
||
|
|
prev = entry.p;
|
||
|
|
delete that[O1][entry.i];
|
||
|
|
entry.r = true;
|
||
|
|
if (prev)
|
||
|
|
prev.n = next;
|
||
|
|
if (next)
|
||
|
|
next.p = prev;
|
||
|
|
if (that[FIRST] == entry)
|
||
|
|
that[FIRST] = next;
|
||
|
|
if (that[LAST] == entry)
|
||
|
|
that[LAST] = prev;
|
||
|
|
that[SIZE]--;
|
||
|
|
}
|
||
|
|
return !!entry;
|
||
|
|
},
|
||
|
|
forEach: function forEach(callbackfn) {
|
||
|
|
var f = ctx(callbackfn, arguments[1], 3),
|
||
|
|
entry;
|
||
|
|
while (entry = entry ? entry.n : this[FIRST]) {
|
||
|
|
f(entry.v, entry.k, this);
|
||
|
|
while (entry && entry.r)
|
||
|
|
entry = entry.p;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
has: function has(key) {
|
||
|
|
return !!getEntry(this, key);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
if ($.DESC)
|
||
|
|
$.setDesc(C.prototype, 'size', {get: function() {
|
||
|
|
return assert.def(this[SIZE]);
|
||
|
|
}});
|
||
|
|
return C;
|
||
|
|
},
|
||
|
|
def: function(that, key, value) {
|
||
|
|
var entry = getEntry(that, key),
|
||
|
|
prev,
|
||
|
|
index;
|
||
|
|
if (entry) {
|
||
|
|
entry.v = value;
|
||
|
|
} else {
|
||
|
|
that[LAST] = entry = {
|
||
|
|
i: index = fastKey(key, true),
|
||
|
|
k: key,
|
||
|
|
v: value,
|
||
|
|
p: prev = that[LAST],
|
||
|
|
n: undefined,
|
||
|
|
r: false
|
||
|
|
};
|
||
|
|
if (!that[FIRST])
|
||
|
|
that[FIRST] = entry;
|
||
|
|
if (prev)
|
||
|
|
prev.n = entry;
|
||
|
|
that[SIZE]++;
|
||
|
|
if (index !== 'F')
|
||
|
|
that[O1][index] = entry;
|
||
|
|
}
|
||
|
|
return that;
|
||
|
|
},
|
||
|
|
getEntry: getEntry,
|
||
|
|
setIter: function(C, NAME, IS_MAP) {
|
||
|
|
__webpack_require__(42)(C, NAME, function(iterated, kind) {
|
||
|
|
set(this, ITER, {
|
||
|
|
o: iterated,
|
||
|
|
k: kind
|
||
|
|
});
|
||
|
|
}, function() {
|
||
|
|
var iter = this[ITER],
|
||
|
|
kind = iter.k,
|
||
|
|
entry = iter.l;
|
||
|
|
while (entry && entry.r)
|
||
|
|
entry = entry.p;
|
||
|
|
if (!iter.o || !(iter.l = entry = entry ? entry.n : iter.o[FIRST])) {
|
||
|
|
iter.o = undefined;
|
||
|
|
return step(1);
|
||
|
|
}
|
||
|
|
if (kind == 'keys')
|
||
|
|
return step(0, entry.k);
|
||
|
|
if (kind == 'values')
|
||
|
|
return step(0, entry.v);
|
||
|
|
return step(0, [entry.k, entry.v]);
|
||
|
|
}, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
BUGGY = __webpack_require__(41).BUGGY,
|
||
|
|
forOf = __webpack_require__(61),
|
||
|
|
species = __webpack_require__(55),
|
||
|
|
assertInstance = __webpack_require__(16).inst;
|
||
|
|
module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
|
||
|
|
var Base = $.g[NAME],
|
||
|
|
C = Base,
|
||
|
|
ADDER = IS_MAP ? 'set' : 'add',
|
||
|
|
proto = C && C.prototype,
|
||
|
|
O = {};
|
||
|
|
function fixMethod(KEY) {
|
||
|
|
var fn = proto[KEY];
|
||
|
|
__webpack_require__(5)(proto, KEY, KEY == 'delete' ? function(a) {
|
||
|
|
return fn.call(this, a === 0 ? 0 : a);
|
||
|
|
} : KEY == 'has' ? function has(a) {
|
||
|
|
return fn.call(this, a === 0 ? 0 : a);
|
||
|
|
} : KEY == 'get' ? function get(a) {
|
||
|
|
return fn.call(this, a === 0 ? 0 : a);
|
||
|
|
} : KEY == 'add' ? function add(a) {
|
||
|
|
fn.call(this, a === 0 ? 0 : a);
|
||
|
|
return this;
|
||
|
|
} : function set(a, b) {
|
||
|
|
fn.call(this, a === 0 ? 0 : a, b);
|
||
|
|
return this;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (!$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)) {
|
||
|
|
C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
|
||
|
|
__webpack_require__(63)(C.prototype, methods);
|
||
|
|
} else {
|
||
|
|
var inst = new C,
|
||
|
|
chain = inst[ADDER](IS_WEAK ? {} : -0, 1),
|
||
|
|
buggyZero;
|
||
|
|
if (!__webpack_require__(51)(function(iter) {
|
||
|
|
new C(iter);
|
||
|
|
})) {
|
||
|
|
C = wrapper(function(target, iterable) {
|
||
|
|
assertInstance(target, C, NAME);
|
||
|
|
var that = new Base;
|
||
|
|
if (iterable != undefined)
|
||
|
|
forOf(iterable, IS_MAP, that[ADDER], that);
|
||
|
|
return that;
|
||
|
|
});
|
||
|
|
C.prototype = proto;
|
||
|
|
proto.constructor = C;
|
||
|
|
}
|
||
|
|
IS_WEAK || inst.forEach(function(val, key) {
|
||
|
|
buggyZero = 1 / key === -Infinity;
|
||
|
|
});
|
||
|
|
if (buggyZero) {
|
||
|
|
fixMethod('delete');
|
||
|
|
fixMethod('has');
|
||
|
|
IS_MAP && fixMethod('get');
|
||
|
|
}
|
||
|
|
if (buggyZero || chain !== inst)
|
||
|
|
fixMethod(ADDER);
|
||
|
|
}
|
||
|
|
__webpack_require__(12).set(C, NAME);
|
||
|
|
O[NAME] = C;
|
||
|
|
$def($def.G + $def.W + $def.F * (C != Base), O);
|
||
|
|
species(C);
|
||
|
|
species($.core[NAME]);
|
||
|
|
if (!IS_WEAK)
|
||
|
|
common.setIter(C, NAME, IS_MAP);
|
||
|
|
return C;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var strong = __webpack_require__(65);
|
||
|
|
__webpack_require__(66)('Set', function(get) {
|
||
|
|
return function Set() {
|
||
|
|
return get(this, arguments[0]);
|
||
|
|
};
|
||
|
|
}, {add: function add(value) {
|
||
|
|
return strong.def(this, value = value === 0 ? 0 : value, value);
|
||
|
|
}}, strong);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
weak = __webpack_require__(69),
|
||
|
|
leakStore = weak.leakStore,
|
||
|
|
ID = weak.ID,
|
||
|
|
WEAK = weak.WEAK,
|
||
|
|
has = $.has,
|
||
|
|
isObject = $.isObject,
|
||
|
|
isExtensible = Object.isExtensible || isObject,
|
||
|
|
tmp = {};
|
||
|
|
var $WeakMap = __webpack_require__(66)('WeakMap', function(get) {
|
||
|
|
return function WeakMap() {
|
||
|
|
return get(this, arguments[0]);
|
||
|
|
};
|
||
|
|
}, {
|
||
|
|
get: function get(key) {
|
||
|
|
if (isObject(key)) {
|
||
|
|
if (!isExtensible(key))
|
||
|
|
return leakStore(this).get(key);
|
||
|
|
if (has(key, WEAK))
|
||
|
|
return key[WEAK][this[ID]];
|
||
|
|
}
|
||
|
|
},
|
||
|
|
set: function set(key, value) {
|
||
|
|
return weak.def(this, key, value);
|
||
|
|
}
|
||
|
|
}, weak, true, true);
|
||
|
|
if (new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7) {
|
||
|
|
$.each.call(['delete', 'has', 'get', 'set'], function(key) {
|
||
|
|
var proto = $WeakMap.prototype,
|
||
|
|
method = proto[key];
|
||
|
|
__webpack_require__(5)(proto, key, function(a, b) {
|
||
|
|
if (isObject(a) && !isExtensible(a)) {
|
||
|
|
var result = leakStore(this)[key](a, b);
|
||
|
|
return key == 'set' ? this : result;
|
||
|
|
}
|
||
|
|
return method.call(this, a, b);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
safe = __webpack_require__(6).safe,
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
forOf = __webpack_require__(61),
|
||
|
|
$has = $.has,
|
||
|
|
isObject = $.isObject,
|
||
|
|
hide = $.hide,
|
||
|
|
isExtensible = Object.isExtensible || isObject,
|
||
|
|
id = 0,
|
||
|
|
ID = safe('id'),
|
||
|
|
WEAK = safe('weak'),
|
||
|
|
LEAK = safe('leak'),
|
||
|
|
method = __webpack_require__(14),
|
||
|
|
find = method(5),
|
||
|
|
findIndex = method(6);
|
||
|
|
function findFrozen(store, key) {
|
||
|
|
return find(store.array, function(it) {
|
||
|
|
return it[0] === key;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function leakStore(that) {
|
||
|
|
return that[LEAK] || hide(that, LEAK, {
|
||
|
|
array: [],
|
||
|
|
get: function(key) {
|
||
|
|
var entry = findFrozen(this, key);
|
||
|
|
if (entry)
|
||
|
|
return entry[1];
|
||
|
|
},
|
||
|
|
has: function(key) {
|
||
|
|
return !!findFrozen(this, key);
|
||
|
|
},
|
||
|
|
set: function(key, value) {
|
||
|
|
var entry = findFrozen(this, key);
|
||
|
|
if (entry)
|
||
|
|
entry[1] = value;
|
||
|
|
else
|
||
|
|
this.array.push([key, value]);
|
||
|
|
},
|
||
|
|
'delete': function(key) {
|
||
|
|
var index = findIndex(this.array, function(it) {
|
||
|
|
return it[0] === key;
|
||
|
|
});
|
||
|
|
if (~index)
|
||
|
|
this.array.splice(index, 1);
|
||
|
|
return !!~index;
|
||
|
|
}
|
||
|
|
})[LEAK];
|
||
|
|
}
|
||
|
|
module.exports = {
|
||
|
|
getConstructor: function(wrapper, NAME, IS_MAP, ADDER) {
|
||
|
|
var C = wrapper(function(that, iterable) {
|
||
|
|
$.set(assert.inst(that, C, NAME), ID, id++);
|
||
|
|
if (iterable != undefined)
|
||
|
|
forOf(iterable, IS_MAP, that[ADDER], that);
|
||
|
|
});
|
||
|
|
__webpack_require__(63)(C.prototype, {
|
||
|
|
'delete': function(key) {
|
||
|
|
if (!isObject(key))
|
||
|
|
return false;
|
||
|
|
if (!isExtensible(key))
|
||
|
|
return leakStore(this)['delete'](key);
|
||
|
|
return $has(key, WEAK) && $has(key[WEAK], this[ID]) && delete key[WEAK][this[ID]];
|
||
|
|
},
|
||
|
|
has: function has(key) {
|
||
|
|
if (!isObject(key))
|
||
|
|
return false;
|
||
|
|
if (!isExtensible(key))
|
||
|
|
return leakStore(this).has(key);
|
||
|
|
return $has(key, WEAK) && $has(key[WEAK], this[ID]);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return C;
|
||
|
|
},
|
||
|
|
def: function(that, key, value) {
|
||
|
|
if (!isExtensible(assert.obj(key))) {
|
||
|
|
leakStore(that).set(key, value);
|
||
|
|
} else {
|
||
|
|
$has(key, WEAK) || hide(key, WEAK, {});
|
||
|
|
key[WEAK][that[ID]] = value;
|
||
|
|
}
|
||
|
|
return that;
|
||
|
|
},
|
||
|
|
leakStore: leakStore,
|
||
|
|
WEAK: WEAK,
|
||
|
|
ID: ID
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var weak = __webpack_require__(69);
|
||
|
|
__webpack_require__(66)('WeakSet', function(get) {
|
||
|
|
return function WeakSet() {
|
||
|
|
return get(this, arguments[0]);
|
||
|
|
};
|
||
|
|
}, {add: function add(value) {
|
||
|
|
return weak.def(this, value, true);
|
||
|
|
}}, weak, false, true);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
setProto = __webpack_require__(29),
|
||
|
|
$iter = __webpack_require__(41),
|
||
|
|
ITERATOR = __webpack_require__(8)('iterator'),
|
||
|
|
ITER = __webpack_require__(6).safe('iter'),
|
||
|
|
step = $iter.step,
|
||
|
|
assert = __webpack_require__(16),
|
||
|
|
isObject = $.isObject,
|
||
|
|
getProto = $.getProto,
|
||
|
|
$Reflect = $.g.Reflect,
|
||
|
|
_apply = Function.apply,
|
||
|
|
assertObject = assert.obj,
|
||
|
|
_isExtensible = Object.isExtensible || isObject,
|
||
|
|
_preventExtensions = Object.preventExtensions,
|
||
|
|
buggyEnumerate = !($Reflect && $Reflect.enumerate && ITERATOR in $Reflect.enumerate({}));
|
||
|
|
function Enumerate(iterated) {
|
||
|
|
$.set(this, ITER, {
|
||
|
|
o: iterated,
|
||
|
|
k: undefined,
|
||
|
|
i: 0
|
||
|
|
});
|
||
|
|
}
|
||
|
|
$iter.create(Enumerate, 'Object', function() {
|
||
|
|
var iter = this[ITER],
|
||
|
|
keys = iter.k,
|
||
|
|
key;
|
||
|
|
if (keys == undefined) {
|
||
|
|
iter.k = keys = [];
|
||
|
|
for (key in iter.o)
|
||
|
|
keys.push(key);
|
||
|
|
}
|
||
|
|
do {
|
||
|
|
if (iter.i >= keys.length)
|
||
|
|
return step(1);
|
||
|
|
} while (!((key = keys[iter.i++]) in iter.o));
|
||
|
|
return step(0, key);
|
||
|
|
});
|
||
|
|
var reflect = {
|
||
|
|
apply: function apply(target, thisArgument, argumentsList) {
|
||
|
|
return _apply.call(target, thisArgument, argumentsList);
|
||
|
|
},
|
||
|
|
construct: function construct(target, argumentsList) {
|
||
|
|
var proto = assert.fn(arguments.length < 3 ? target : arguments[2]).prototype,
|
||
|
|
instance = $.create(isObject(proto) ? proto : Object.prototype),
|
||
|
|
result = _apply.call(target, instance, argumentsList);
|
||
|
|
return isObject(result) ? result : instance;
|
||
|
|
},
|
||
|
|
defineProperty: function defineProperty(target, propertyKey, attributes) {
|
||
|
|
assertObject(target);
|
||
|
|
try {
|
||
|
|
$.setDesc(target, propertyKey, attributes);
|
||
|
|
return true;
|
||
|
|
} catch (e) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
deleteProperty: function deleteProperty(target, propertyKey) {
|
||
|
|
var desc = $.getDesc(assertObject(target), propertyKey);
|
||
|
|
return desc && !desc.configurable ? false : delete target[propertyKey];
|
||
|
|
},
|
||
|
|
get: function get(target, propertyKey) {
|
||
|
|
var receiver = arguments.length < 3 ? target : arguments[2],
|
||
|
|
desc = $.getDesc(assertObject(target), propertyKey),
|
||
|
|
proto;
|
||
|
|
if (desc)
|
||
|
|
return $.has(desc, 'value') ? desc.value : desc.get === undefined ? undefined : desc.get.call(receiver);
|
||
|
|
return isObject(proto = getProto(target)) ? get(proto, propertyKey, receiver) : undefined;
|
||
|
|
},
|
||
|
|
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {
|
||
|
|
return $.getDesc(assertObject(target), propertyKey);
|
||
|
|
},
|
||
|
|
getPrototypeOf: function getPrototypeOf(target) {
|
||
|
|
return getProto(assertObject(target));
|
||
|
|
},
|
||
|
|
has: function has(target, propertyKey) {
|
||
|
|
return propertyKey in target;
|
||
|
|
},
|
||
|
|
isExtensible: function isExtensible(target) {
|
||
|
|
return _isExtensible(assertObject(target));
|
||
|
|
},
|
||
|
|
ownKeys: __webpack_require__(72),
|
||
|
|
preventExtensions: function preventExtensions(target) {
|
||
|
|
assertObject(target);
|
||
|
|
try {
|
||
|
|
if (_preventExtensions)
|
||
|
|
_preventExtensions(target);
|
||
|
|
return true;
|
||
|
|
} catch (e) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
set: function set(target, propertyKey, V) {
|
||
|
|
var receiver = arguments.length < 4 ? target : arguments[3],
|
||
|
|
ownDesc = $.getDesc(assertObject(target), propertyKey),
|
||
|
|
existingDescriptor,
|
||
|
|
proto;
|
||
|
|
if (!ownDesc) {
|
||
|
|
if (isObject(proto = getProto(target))) {
|
||
|
|
return set(proto, propertyKey, V, receiver);
|
||
|
|
}
|
||
|
|
ownDesc = $.desc(0);
|
||
|
|
}
|
||
|
|
if ($.has(ownDesc, 'value')) {
|
||
|
|
if (ownDesc.writable === false || !isObject(receiver))
|
||
|
|
return false;
|
||
|
|
existingDescriptor = $.getDesc(receiver, propertyKey) || $.desc(0);
|
||
|
|
existingDescriptor.value = V;
|
||
|
|
$.setDesc(receiver, propertyKey, existingDescriptor);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
if (setProto)
|
||
|
|
reflect.setPrototypeOf = function setPrototypeOf(target, proto) {
|
||
|
|
setProto.check(target, proto);
|
||
|
|
try {
|
||
|
|
setProto.set(target, proto);
|
||
|
|
return true;
|
||
|
|
} catch (e) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
$def($def.G, {Reflect: {}});
|
||
|
|
$def($def.S + $def.F * buggyEnumerate, 'Reflect', {enumerate: function enumerate(target) {
|
||
|
|
return new Enumerate(assertObject(target));
|
||
|
|
}});
|
||
|
|
$def($def.S, 'Reflect', reflect);
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
assertObject = __webpack_require__(16).obj;
|
||
|
|
module.exports = function ownKeys(it) {
|
||
|
|
assertObject(it);
|
||
|
|
var keys = $.getNames(it),
|
||
|
|
getSymbols = $.getSymbols;
|
||
|
|
return getSymbols ? keys.concat(getSymbols(it)) : keys;
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$includes = __webpack_require__(17)(true);
|
||
|
|
$def($def.P, 'Array', {includes: function includes(el) {
|
||
|
|
return $includes(this, el, arguments[1]);
|
||
|
|
}});
|
||
|
|
__webpack_require__(7)('includes');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$at = __webpack_require__(40)(true);
|
||
|
|
$def($def.P, 'String', {at: function at(pos) {
|
||
|
|
return $at(this, pos);
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$pad = __webpack_require__(76);
|
||
|
|
$def($def.P, 'String', {lpad: function lpad(n) {
|
||
|
|
return $pad(this, n, arguments[1], true);
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
repeat = __webpack_require__(47);
|
||
|
|
module.exports = function(that, minLength, fillChar, left) {
|
||
|
|
var S = String($.assertDefined(that));
|
||
|
|
if (minLength === undefined)
|
||
|
|
return S;
|
||
|
|
var intMinLength = $.toInteger(minLength);
|
||
|
|
var fillLen = intMinLength - S.length;
|
||
|
|
if (fillLen < 0 || fillLen === Infinity) {
|
||
|
|
throw new RangeError('Cannot satisfy string length ' + minLength + ' for string: ' + S);
|
||
|
|
}
|
||
|
|
var sFillStr = fillChar === undefined ? ' ' : String(fillChar);
|
||
|
|
var sFillVal = repeat.call(sFillStr, Math.ceil(fillLen / sFillStr.length));
|
||
|
|
if (sFillVal.length > fillLen)
|
||
|
|
sFillVal = left ? sFillVal.slice(sFillVal.length - fillLen) : sFillVal.slice(0, fillLen);
|
||
|
|
return left ? sFillVal.concat(S) : S.concat(sFillVal);
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$pad = __webpack_require__(76);
|
||
|
|
$def($def.P, 'String', {rpad: function rpad(n) {
|
||
|
|
return $pad(this, n, arguments[1], false);
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4);
|
||
|
|
$def($def.S, 'RegExp', {escape: __webpack_require__(18)(/[\\^$*+?.()|[\]{}]/g, '\\$&', true)});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
ownKeys = __webpack_require__(72);
|
||
|
|
$def($def.S, 'Object', {getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
|
||
|
|
var O = $.toObject(object),
|
||
|
|
result = {};
|
||
|
|
$.each.call(ownKeys(O), function(key) {
|
||
|
|
$.setDesc(result, key, $.desc(0, $.getDesc(O, key)));
|
||
|
|
});
|
||
|
|
return result;
|
||
|
|
}});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4);
|
||
|
|
function createObjectToArray(isEntries) {
|
||
|
|
return function(object) {
|
||
|
|
var O = $.toObject(object),
|
||
|
|
keys = $.getKeys(O),
|
||
|
|
length = keys.length,
|
||
|
|
i = 0,
|
||
|
|
result = Array(length),
|
||
|
|
key;
|
||
|
|
if (isEntries)
|
||
|
|
while (length > i)
|
||
|
|
result[i] = [key = keys[i++], O[key]];
|
||
|
|
else
|
||
|
|
while (length > i)
|
||
|
|
result[i] = O[keys[i++]];
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
$def($def.S, 'Object', {
|
||
|
|
values: createObjectToArray(false),
|
||
|
|
entries: createObjectToArray(true)
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
__webpack_require__(82)('Map');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
forOf = __webpack_require__(61);
|
||
|
|
module.exports = function(NAME) {
|
||
|
|
$def($def.P, NAME, {toJSON: function toJSON() {
|
||
|
|
var arr = [];
|
||
|
|
forOf(this, false, arr.push, arr);
|
||
|
|
return arr;
|
||
|
|
}});
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
__webpack_require__(82)('Set');
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $def = __webpack_require__(4),
|
||
|
|
$task = __webpack_require__(62);
|
||
|
|
$def($def.G + $def.B, {
|
||
|
|
setImmediate: $task.set,
|
||
|
|
clearImmediate: $task.clear
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
__webpack_require__(53);
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
Iterators = __webpack_require__(41).Iterators,
|
||
|
|
ITERATOR = __webpack_require__(8)('iterator'),
|
||
|
|
ArrayValues = Iterators.Array,
|
||
|
|
NL = $.g.NodeList,
|
||
|
|
HTC = $.g.HTMLCollection,
|
||
|
|
NLProto = NL && NL.prototype,
|
||
|
|
HTCProto = HTC && HTC.prototype;
|
||
|
|
if ($.FW) {
|
||
|
|
if (NL && !(ITERATOR in NLProto))
|
||
|
|
$.hide(NLProto, ITERATOR, ArrayValues);
|
||
|
|
if (HTC && !(ITERATOR in HTCProto))
|
||
|
|
$.hide(HTCProto, ITERATOR, ArrayValues);
|
||
|
|
}
|
||
|
|
Iterators.NodeList = Iterators.HTMLCollection = ArrayValues;
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
invoke = __webpack_require__(13),
|
||
|
|
partial = __webpack_require__(87),
|
||
|
|
navigator = $.g.navigator,
|
||
|
|
MSIE = !!navigator && /MSIE .\./.test(navigator.userAgent);
|
||
|
|
function wrap(set) {
|
||
|
|
return MSIE ? function(fn, time) {
|
||
|
|
return set(invoke(partial, [].slice.call(arguments, 2), $.isFunction(fn) ? fn : Function(fn)), time);
|
||
|
|
} : set;
|
||
|
|
}
|
||
|
|
$def($def.G + $def.B + $def.F * MSIE, {
|
||
|
|
setTimeout: wrap($.g.setTimeout),
|
||
|
|
setInterval: wrap($.g.setInterval)
|
||
|
|
});
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
'use strict';
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
invoke = __webpack_require__(13),
|
||
|
|
assertFunction = __webpack_require__(16).fn;
|
||
|
|
module.exports = function() {
|
||
|
|
var fn = assertFunction(this),
|
||
|
|
length = arguments.length,
|
||
|
|
pargs = Array(length),
|
||
|
|
i = 0,
|
||
|
|
_ = $.path._,
|
||
|
|
holder = false;
|
||
|
|
while (length > i)
|
||
|
|
if ((pargs[i] = arguments[i++]) === _)
|
||
|
|
holder = true;
|
||
|
|
return function() {
|
||
|
|
var that = this,
|
||
|
|
_length = arguments.length,
|
||
|
|
j = 0,
|
||
|
|
k = 0,
|
||
|
|
args;
|
||
|
|
if (!holder && !_length)
|
||
|
|
return invoke(fn, pargs, that);
|
||
|
|
args = pargs.slice();
|
||
|
|
if (holder)
|
||
|
|
for (; length > j; j++)
|
||
|
|
if (args[j] === _)
|
||
|
|
args[j] = arguments[k++];
|
||
|
|
while (_length > k)
|
||
|
|
args.push(arguments[k++]);
|
||
|
|
return invoke(fn, args, that);
|
||
|
|
};
|
||
|
|
};
|
||
|
|
}, function(module, exports, __webpack_require__) {
|
||
|
|
var $ = __webpack_require__(2),
|
||
|
|
$def = __webpack_require__(4),
|
||
|
|
$Array = $.core.Array || Array,
|
||
|
|
statics = {};
|
||
|
|
function setStatics(keys, length) {
|
||
|
|
$.each.call(keys.split(','), function(key) {
|
||
|
|
if (length == undefined && key in $Array)
|
||
|
|
statics[key] = $Array[key];
|
||
|
|
else if (key in [])
|
||
|
|
statics[key] = __webpack_require__(15)(Function.call, [][key], length);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
setStatics('pop,reverse,shift,keys,values,entries', 1);
|
||
|
|
setStatics('indexOf,every,some,forEach,map,filter,find,findIndex,includes', 3);
|
||
|
|
setStatics('join,slice,concat,push,splice,unshift,sort,lastIndexOf,' + 'reduce,reduceRight,copyWithin,fill,turn');
|
||
|
|
$def($def.S, 'Array', statics);
|
||
|
|
}]);
|
||
|
|
if (typeof module != 'undefined' && module.exports)
|
||
|
|
module.exports = __e;
|
||
|
|
else if (typeof define == 'function' && define.amd)
|
||
|
|
define(function() {
|
||
|
|
return __e;
|
||
|
|
});
|
||
|
|
else
|
||
|
|
__g.core = __e;
|
||
|
|
}();
|
||
|
|
})(require("process"));
|