vmario/Doodle3D-API
0
0
Fork 0
mirror of https://github.com/Doodle3D/Doodle3D-API synced 2024-09-28 07:18:36 +02:00
Code Issues Releases Wiki Activity
5f171ac3ac
Doodle3D-API/jspm_packages/npm/core-js@0.9.18/client/library.js
casperlamboo 5f171ac3ac init release
2015-07-15 15:06:18 +02:00

3150 lines
111 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* */
"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__(1);
__webpack_require__(17);
__webpack_require__(22);
__webpack_require__(24);
__webpack_require__(26);
__webpack_require__(28);
__webpack_require__(29);
__webpack_require__(30);
__webpack_require__(31);
__webpack_require__(32);
__webpack_require__(33);
__webpack_require__(34);
__webpack_require__(38);
__webpack_require__(39);
__webpack_require__(40);
__webpack_require__(41);
__webpack_require__(43);
__webpack_require__(44);
__webpack_require__(47);
__webpack_require__(48);
__webpack_require__(50);
__webpack_require__(52);
__webpack_require__(53);
__webpack_require__(54);
__webpack_require__(55);
__webpack_require__(56);
__webpack_require__(60);
__webpack_require__(63);
__webpack_require__(64);
__webpack_require__(66);
__webpack_require__(67);
__webpack_require__(69);
__webpack_require__(70);
__webpack_require__(71);
__webpack_require__(73);
__webpack_require__(74);
__webpack_require__(75);
__webpack_require__(76);
__webpack_require__(77);
__webpack_require__(79);
__webpack_require__(80);
__webpack_require__(81);
__webpack_require__(82);
__webpack_require__(84);
__webpack_require__(85);
__webpack_require__(86);
__webpack_require__(87);
__webpack_require__(88);
__webpack_require__(89);
__webpack_require__(90);
__webpack_require__(91);
__webpack_require__(92);
__webpack_require__(93);
__webpack_require__(94);
__webpack_require__(95);
__webpack_require__(96);
__webpack_require__(97);
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
cel = __webpack_require__(4),
cof = __webpack_require__(5),
$def = __webpack_require__(9),
invoke = __webpack_require__(10),
arrayMethod = __webpack_require__(11),
IE_PROTO = __webpack_require__(8).safe('__proto__'),
assert = __webpack_require__(13),
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__(14)(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__(15)(/^\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__(16)(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__) {
'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 = false;
$.path = $.core;
return $;
};
}, 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__(6)('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__) {
var global = __webpack_require__(2).g,
store = __webpack_require__(7)('wks');
module.exports = function(name) {
return store[name] || (store[name] = global.Symbol && global.Symbol[name] || __webpack_require__(8).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 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 $ = __webpack_require__(2),
global = $.g,
core = $.core,
isFunction = $.isFunction;
function ctx(fn, that) {
return function() {
return fn.apply(that, arguments);
};
}
$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;
if (own && key in exports)
continue;
out = own ? target[key] : source[key];
if (isGlobal && !isFunction(target[key]))
exp = source[key];
else if (type & $def.B && own)
exp = ctx(out, global);
else if (type & $def.W && target[key] == out)
!function(C) {
exp = function(param) {
return this instanceof C ? new C(param) : C(param);
};
exp.prototype = C.prototype;
}(out);
else
exp = isProto && isFunction(out) ? ctx(Function.call, out) : out;
exports[key] = exp;
if (isProto)
(exports.prototype || (exports.prototype = {}))[key] = out;
}
}
module.exports = $def;
}, 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__(12);
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__(13).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__(5).set,
uid = __webpack_require__(8),
shared = __webpack_require__(7),
$def = __webpack_require__(9),
$redef = __webpack_require__(18),
keyOf = __webpack_require__(19),
enumKeys = __webpack_require__(20),
assertObject = __webpack_require__(13).obj,
ObjectProto = Object.prototype,
DESC = $.DESC,
has = $.has,
$create = $.create,
getDesc = $.getDesc,
setDesc = $.setDesc,
desc = $.desc,
$names = __webpack_require__(21),
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__(6)(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__) {
module.exports = __webpack_require__(2).hide;
}, 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__(9);
$def($def.S, 'Object', {assign: __webpack_require__(23)});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
enumKeys = __webpack_require__(20);
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__(9);
$def($def.S, 'Object', {is: __webpack_require__(25)});
}, 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__(9);
$def($def.S, 'Object', {setPrototypeOf: __webpack_require__(27).set});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
assert = __webpack_require__(13);
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__(12)(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__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
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__(21).get;
try {
fn('z');
} catch (e) {
forced = 1;
}
$def($def.S + $def.F * forced, 'Object', method);
});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
HAS_INSTANCE = __webpack_require__(6)('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__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
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__(9),
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__(9),
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__(9);
$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__(35)(true),
ITER = __webpack_require__(8).safe('iter'),
$iter = __webpack_require__(36),
step = $iter.step;
__webpack_require__(37)(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__(5),
classof = cof.classof,
assert = __webpack_require__(13),
assertObject = assert.obj,
SYMBOL_ITERATOR = __webpack_require__(6)('iterator'),
FF_ITERATOR = '@@iterator',
Iterators = __webpack_require__(7)('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__(9),
$redef = __webpack_require__(18),
$ = __webpack_require__(2),
cof = __webpack_require__(5),
$iter = __webpack_require__(36),
SYMBOL_ITERATOR = __webpack_require__(6)('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__(9),
$at = __webpack_require__(35)(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__(5),
$def = __webpack_require__(9),
toLength = $.toLength;
$def($def.P + $def.F * !__webpack_require__(16)(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__(5),
$def = __webpack_require__(9);
$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__(9);
$def($def.P, 'String', {repeat: __webpack_require__(42)});
}, 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__(5),
$def = __webpack_require__(9);
$def($def.P + $def.F * !__webpack_require__(16)(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__(12),
$def = __webpack_require__(9),
$iter = __webpack_require__(36),
call = __webpack_require__(45);
$def($def.S + $def.F * !__webpack_require__(46)(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__(13).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__(6)('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__(9);
$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__(49),
ITER = __webpack_require__(8).safe('iter'),
$iter = __webpack_require__(36),
step = $iter.step,
Iterators = $iter.Iterators;
__webpack_require__(37)(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__) {
module.exports = function() {};
}, function(module, exports, __webpack_require__) {
__webpack_require__(51)(Array);
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
SPECIES = __webpack_require__(6)('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__(9),
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__(49)('copyWithin');
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
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__(49)('fill');
}, function(module, exports, __webpack_require__) {
'use strict';
var KEY = 'find',
$def = __webpack_require__(9),
forced = true,
$find = __webpack_require__(11)(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__(49)(KEY);
}, function(module, exports, __webpack_require__) {
'use strict';
var KEY = 'findIndex',
$def = __webpack_require__(9),
forced = true,
$find = __webpack_require__(11)(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__(49)(KEY);
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
ctx = __webpack_require__(12),
cof = __webpack_require__(5),
$def = __webpack_require__(9),
assert = __webpack_require__(13),
forOf = __webpack_require__(57),
setProto = __webpack_require__(27).set,
same = __webpack_require__(25),
species = __webpack_require__(51),
SPECIES = __webpack_require__(6)('species'),
RECORD = __webpack_require__(8).safe('record'),
PROMISE = 'Promise',
global = $.g,
process = global.process,
isNode = cof(process) == 'process',
asap = process && process.nextTick || __webpack_require__(58).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__(59)(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__(46)(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__(12),
get = __webpack_require__(36).get,
call = __webpack_require__(45);
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__(12),
cof = __webpack_require__(5),
invoke = __webpack_require__(10),
cel = __webpack_require__(4),
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__(18);
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__(61);
__webpack_require__(62)('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__(12),
safe = __webpack_require__(8).safe,
assert = __webpack_require__(13),
forOf = __webpack_require__(57),
step = __webpack_require__(36).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__(59)(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__(37)(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__(9),
$iter = __webpack_require__(36),
BUGGY = $iter.BUGGY,
forOf = __webpack_require__(57),
assertInstance = __webpack_require__(13).inst,
INTERNAL = __webpack_require__(8).safe('internal');
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 = {};
if (!$.DESC || !$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)) {
C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
__webpack_require__(59)(C.prototype, methods);
} else {
C = wrapper(function(target, iterable) {
assertInstance(target, C, NAME);
target[INTERNAL] = new Base;
if (iterable != undefined)
forOf(iterable, IS_MAP, target[ADDER], target);
});
$.each.call('add,clear,delete,forEach,get,has,set,keys,values,entries'.split(','), function(KEY) {
var chain = KEY == 'add' || KEY == 'set';
if (KEY in proto)
$.hide(C.prototype, KEY, function(a, b) {
var result = this[INTERNAL][KEY](a === 0 ? 0 : a, b);
return chain ? this : result;
});
});
if ('size' in proto)
$.setDesc(C.prototype, 'size', {get: function() {
return this[INTERNAL].size;
}});
}
__webpack_require__(5).set(C, NAME);
O[NAME] = C;
$def($def.G + $def.W + $def.F, O);
__webpack_require__(51)(C);
if (!IS_WEAK)
common.setIter(C, NAME, IS_MAP);
return C;
};
}, function(module, exports, __webpack_require__) {
'use strict';
var strong = __webpack_require__(61);
__webpack_require__(62)('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__(65),
leakStore = weak.leakStore,
ID = weak.ID,
WEAK = weak.WEAK,
has = $.has,
isObject = $.isObject,
isExtensible = Object.isExtensible || isObject,
tmp = {};
var $WeakMap = __webpack_require__(62)('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__(18)(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__(8).safe,
assert = __webpack_require__(13),
forOf = __webpack_require__(57),
$has = $.has,
isObject = $.isObject,
hide = $.hide,
isExtensible = Object.isExtensible || isObject,
id = 0,
ID = safe('id'),
WEAK = safe('weak'),
LEAK = safe('leak'),
method = __webpack_require__(11),
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__(59)(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__(65);
__webpack_require__(62)('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__(9),
setProto = __webpack_require__(27),
$iter = __webpack_require__(36),
ITERATOR = __webpack_require__(6)('iterator'),
ITER = __webpack_require__(8).safe('iter'),
step = $iter.step,
assert = __webpack_require__(13),
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__(68),
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__(13).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__(9),
$includes = __webpack_require__(14)(true);
$def($def.P, 'Array', {includes: function includes(el) {
return $includes(this, el, arguments[1]);
}});
__webpack_require__(49)('includes');
}, function(module, exports, __webpack_require__) {
'use strict';
var $def = __webpack_require__(9),
$at = __webpack_require__(35)(true);
$def($def.P, 'String', {at: function at(pos) {
return $at(this, pos);
}});
}, function(module, exports, __webpack_require__) {
'use strict';
var $def = __webpack_require__(9),
$pad = __webpack_require__(72);
$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__(42);
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__(9),
$pad = __webpack_require__(72);
$def($def.P, 'String', {rpad: function rpad(n) {
return $pad(this, n, arguments[1], false);
}});
}, function(module, exports, __webpack_require__) {
var $def = __webpack_require__(9);
$def($def.S, 'RegExp', {escape: __webpack_require__(15)(/[\\^$*+?.()|[\]{}]/g, '\\$&', true)});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
ownKeys = __webpack_require__(68);
$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__(9);
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__(78)('Map');
}, function(module, exports, __webpack_require__) {
var $def = __webpack_require__(9),
forOf = __webpack_require__(57);
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__(78)('Set');
}, function(module, exports, __webpack_require__) {
var $def = __webpack_require__(9),
$task = __webpack_require__(58);
$def($def.G + $def.B, {
setImmediate: $task.set,
clearImmediate: $task.clear
});
}, function(module, exports, __webpack_require__) {
__webpack_require__(48);
var $ = __webpack_require__(2),
Iterators = __webpack_require__(36).Iterators,
ITERATOR = __webpack_require__(6)('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__(9),
invoke = __webpack_require__(10),
partial = __webpack_require__(83),
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__(10),
assertFunction = __webpack_require__(13).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),
ctx = __webpack_require__(12),
$def = __webpack_require__(9),
assign = __webpack_require__(23),
keyOf = __webpack_require__(19),
ITER = __webpack_require__(8).safe('iter'),
assert = __webpack_require__(13),
$iter = __webpack_require__(36),
forOf = __webpack_require__(57),
step = $iter.step,
getKeys = $.getKeys,
toObject = $.toObject,
has = $.has;
function Dict(iterable) {
var dict = $.create(null);
if (iterable != undefined) {
if ($iter.is(iterable)) {
forOf(iterable, true, function(key, value) {
dict[key] = value;
});
} else
assign(dict, iterable);
}
return dict;
}
Dict.prototype = null;
function DictIterator(iterated, kind) {
$.set(this, ITER, {
o: toObject(iterated),
a: getKeys(iterated),
i: 0,
k: kind
});
}
$iter.create(DictIterator, 'Dict', function() {
var iter = this[ITER],
O = iter.o,
keys = iter.a,
kind = iter.k,
key;
do {
if (iter.i >= keys.length) {
iter.o = undefined;
return step(1);
}
} while (!has(O, key = keys[iter.i++]));
if (kind == 'keys')
return step(0, key);
if (kind == 'values')
return step(0, O[key]);
return step(0, [key, O[key]]);
});
function createDictIter(kind) {
return function(it) {
return new DictIterator(it, kind);
};
}
function generic(A, B) {
return typeof A == 'function' ? A : B;
}
function createDictMethod(TYPE) {
var IS_MAP = TYPE == 1,
IS_EVERY = TYPE == 4;
return function(object, callbackfn, that) {
var f = ctx(callbackfn, that, 3),
O = toObject(object),
result = IS_MAP || TYPE == 7 || TYPE == 2 ? new (generic(this, Dict)) : undefined,
key,
val,
res;
for (key in O)
if (has(O, key)) {
val = O[key];
res = f(val, key, object);
if (TYPE) {
if (IS_MAP)
result[key] = res;
else if (res)
switch (TYPE) {
case 2:
result[key] = val;
break;
case 3:
return true;
case 5:
return val;
case 6:
return key;
case 7:
result[res[0]] = res[1];
}
else if (IS_EVERY)
return false;
}
}
return TYPE == 3 || IS_EVERY ? IS_EVERY : result;
};
}
function createDictReduce(IS_TURN) {
return function(object, mapfn, init) {
assert.fn(mapfn);
var O = toObject(object),
keys = getKeys(O),
length = keys.length,
i = 0,
memo,
key,
result;
if (IS_TURN) {
memo = init == undefined ? new (generic(this, Dict)) : Object(init);
} else if (arguments.length < 3) {
assert(length, 'Reduce of empty object with no initial value');
memo = O[keys[i++]];
} else
memo = Object(init);
while (length > i)
if (has(O, key = keys[i++])) {
result = mapfn(memo, O[key], key, object);
if (IS_TURN) {
if (result === false)
break;
} else
memo = result;
}
return memo;
};
}
var findKey = createDictMethod(6);
$def($def.G + $def.F, {Dict: Dict});
$def($def.S, 'Dict', {
keys: createDictIter('keys'),
values: createDictIter('values'),
entries: createDictIter('entries'),
forEach: createDictMethod(0),
map: createDictMethod(1),
filter: createDictMethod(2),
some: createDictMethod(3),
every: createDictMethod(4),
find: createDictMethod(5),
findKey: findKey,
mapPairs: createDictMethod(7),
reduce: createDictReduce(false),
turn: createDictReduce(true),
keyOf: keyOf,
includes: function(object, el) {
return (el == el ? keyOf(object, el) : findKey(object, function(it) {
return it != it;
})) !== undefined;
},
has: has,
get: function(object, key) {
if (has(object, key))
return object[key];
},
set: $.def,
isDict: function(it) {
return $.isObject(it) && $.getProto(it) === Dict.prototype;
}
});
}, function(module, exports, __webpack_require__) {
var core = __webpack_require__(2).core,
$iter = __webpack_require__(36);
core.isIterable = $iter.is;
core.getIterator = $iter.get;
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
ctx = __webpack_require__(12),
safe = __webpack_require__(8).safe,
$def = __webpack_require__(9),
$iter = __webpack_require__(36),
forOf = __webpack_require__(57),
ENTRIES = safe('entries'),
FN = safe('fn'),
ITER = safe('iter'),
call = __webpack_require__(45),
getIterator = $iter.get,
setIterator = $iter.set,
createIterator = $iter.create;
function $for(iterable, entries) {
if (!(this instanceof $for))
return new $for(iterable, entries);
this[ITER] = getIterator(iterable);
this[ENTRIES] = !!entries;
}
createIterator($for, 'Wrapper', function() {
return this[ITER].next();
});
var $forProto = $for.prototype;
setIterator($forProto, function() {
return this[ITER];
});
function createChainIterator(next) {
function Iterator(iter, fn, that) {
this[ITER] = getIterator(iter);
this[ENTRIES] = iter[ENTRIES];
this[FN] = ctx(fn, that, iter[ENTRIES] ? 2 : 1);
}
createIterator(Iterator, 'Chain', next, $forProto);
setIterator(Iterator.prototype, $.that);
return Iterator;
}
var MapIter = createChainIterator(function() {
var step = this[ITER].next();
return step.done ? step : $iter.step(0, call(this[ITER], this[FN], step.value, this[ENTRIES]));
});
var FilterIter = createChainIterator(function() {
for (; ; ) {
var step = this[ITER].next();
if (step.done || call(this[ITER], this[FN], step.value, this[ENTRIES]))
return step;
}
});
__webpack_require__(59)($forProto, {
of: function(fn, that) {
forOf(this, this[ENTRIES], fn, that);
},
array: function(fn, that) {
var result = [];
forOf(fn != undefined ? this.map(fn, that) : this, false, result.push, result);
return result;
},
filter: function(fn, that) {
return new FilterIter(this, fn, that);
},
map: function(fn, that) {
return new MapIter(this, fn, that);
}
});
$for.isIterable = $iter.is;
$for.getIterator = getIterator;
$def($def.G + $def.F, {$for: $for});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
partial = __webpack_require__(83);
$def($def.G + $def.F, {delay: function(time) {
return new ($.core.Promise || $.g.Promise)(function(resolve) {
setTimeout(partial.call(resolve, true), time);
});
}});
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
$def = __webpack_require__(9);
$.core._ = $.path._ = $.path._ || {};
$def($def.P + $def.F, 'Function', {part: __webpack_require__(83)});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
ownKeys = __webpack_require__(68);
function define(target, mixin) {
var keys = ownKeys($.toObject(mixin)),
length = keys.length,
i = 0,
key;
while (length > i)
$.setDesc(target, key = keys[i++], $.getDesc(mixin, key));
return target;
}
$def($def.S + $def.F, 'Object', {
isObject: $.isObject,
classof: __webpack_require__(5).classof,
define: define,
make: function(proto, mixin) {
return define($.create(proto), mixin);
}
});
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
assertFunction = __webpack_require__(13).fn;
$def($def.P + $def.F, 'Array', {turn: function(fn, target) {
assertFunction(fn);
var memo = target == undefined ? [] : Object(target),
O = $.ES5Object(this),
length = $.toLength(O.length),
index = 0;
while (length > index)
if (fn(memo, O[index], index++, this) === false)
break;
return memo;
}});
__webpack_require__(49)('turn');
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
ITER = __webpack_require__(8).safe('iter');
__webpack_require__(37)(Number, 'Number', function(iterated) {
$.set(this, ITER, {
l: $.toLength(iterated),
i: 0
});
}, function() {
var iter = this[ITER],
i = iter.i++,
done = i >= iter.l;
return {
done: done,
value: done ? undefined : i
};
});
}, function(module, exports, __webpack_require__) {
'use strict';
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
invoke = __webpack_require__(10),
methods = {};
methods.random = function(lim) {
var a = +this,
b = lim == undefined ? 0 : +lim,
m = Math.min(a, b);
return Math.random() * (Math.max(a, b) - m) + m;
};
if ($.FW)
$.each.call(('round,floor,ceil,abs,sin,asin,cos,acos,tan,atan,exp,sqrt,max,min,pow,atan2,' + 'acosh,asinh,atanh,cbrt,clz32,cosh,expm1,hypot,imul,log1p,log10,log2,sign,sinh,tanh,trunc').split(','), function(key) {
var fn = Math[key];
if (fn)
methods[key] = function() {
var args = [+this],
i = 0;
while (arguments.length > i)
args.push(arguments[i++]);
return invoke(fn, args);
};
});
$def($def.P + $def.F, 'Number', methods);
}, function(module, exports, __webpack_require__) {
var $def = __webpack_require__(9),
replacer = __webpack_require__(15);
var escapeHTMLDict = {
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&quot;',
"'": '&apos;'
},
unescapeHTMLDict = {},
key;
for (key in escapeHTMLDict)
unescapeHTMLDict[escapeHTMLDict[key]] = key;
$def($def.P + $def.F, 'String', {
escapeHTML: replacer(/[&<>"']/g, escapeHTMLDict),
unescapeHTML: replacer(/&(?:amp|lt|gt|quot|apos);/g, unescapeHTMLDict)
});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
core = $.core,
formatRegExp = /\b\w\w?\b/g,
flexioRegExp = /:(.*)\|(.*)$/,
locales = {},
current = 'en',
SECONDS = 'Seconds',
MINUTES = 'Minutes',
HOURS = 'Hours',
DATE = 'Date',
MONTH = 'Month',
YEAR = 'FullYear';
function lz(num) {
return num > 9 ? num : '0' + num;
}
function createFormat(prefix) {
return function(template, locale) {
var that = this,
dict = locales[$.has(locales, locale) ? locale : current];
function get(unit) {
return that[prefix + unit]();
}
return String(template).replace(formatRegExp, function(part) {
switch (part) {
case 's':
return get(SECONDS);
case 'ss':
return lz(get(SECONDS));
case 'm':
return get(MINUTES);
case 'mm':
return lz(get(MINUTES));
case 'h':
return get(HOURS);
case 'hh':
return lz(get(HOURS));
case 'D':
return get(DATE);
case 'DD':
return lz(get(DATE));
case 'W':
return dict[0][get('Day')];
case 'N':
return get(MONTH) + 1;
case 'NN':
return lz(get(MONTH) + 1);
case 'M':
return dict[2][get(MONTH)];
case 'MM':
return dict[1][get(MONTH)];
case 'Y':
return get(YEAR);
case 'YY':
return lz(get(YEAR) % 100);
}
return part;
});
};
}
function addLocale(lang, locale) {
function split(index) {
var result = [];
$.each.call(locale.months.split(','), function(it) {
result.push(it.replace(flexioRegExp, '$' + index));
});
return result;
}
locales[lang] = [locale.weekdays.split(','), split(1), split(2)];
return core;
}
$def($def.P + $def.F, DATE, {
format: createFormat('get'),
formatUTC: createFormat('getUTC')
});
addLocale(current, {
weekdays: 'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday',
months: 'January,February,March,April,May,June,July,August,September,October,November,December'
});
addLocale('ru', {
weekdays: 'Воскресенье,Понедельник,Вторник,Среда,Четверг,Пятница,Суббота',
months: 'Январ:я|ь,Феврал:я|ь,Март:а|,Апрел:я|ь,Ма:я|й,Июн:я|ь,' + 'Июл:я|ь,Август:а|,Сентябр:я|ь,Октябр:я|ь,Ноябр:я|ь,Декабр:я|ь'
});
core.locale = function(locale) {
return $.has(locales, locale) ? current = locale : current;
};
core.addLocale = addLocale;
}, function(module, exports, __webpack_require__) {
var $def = __webpack_require__(9);
$def($def.G + $def.F, {global: __webpack_require__(2).g});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
log = {},
enabled = true;
$.each.call(('assert,clear,count,debug,dir,dirxml,error,exception,' + 'group,groupCollapsed,groupEnd,info,isIndependentlyComposed,log,' + 'markTimeline,profile,profileEnd,table,time,timeEnd,timeline,' + 'timelineEnd,timeStamp,trace,warn').split(','), function(key) {
log[key] = function() {
if (enabled && $.g.console && $.isFunction(console[key])) {
return Function.apply.call(console[key], console, arguments);
}
};
});
$def($def.G + $def.F, {log: __webpack_require__(23)(log.log, log, {
enable: function() {
enabled = true;
},
disable: function() {
enabled = false;
}
})});
}, function(module, exports, __webpack_require__) {
var $ = __webpack_require__(2),
$def = __webpack_require__(9),
$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__(12)(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"));
Reference in New Issue View Git Blame Copy Permalink