Created
May 30, 2017 16:44
-
-
Save Apidcloud/2b0e6009c4f6f15b272a6dbf1739c6bc to your computer and use it in GitHub Desktop.
Exports is not defined - Weback 2 + Babel Transform Runtime Issue
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var SC = | |
/******/ (function(modules) { // webpackBootstrap | |
/******/ // The module cache | |
/******/ var installedModules = {}; | |
/******/ | |
/******/ // The require function | |
/******/ function __webpack_require__(moduleId) { | |
/******/ | |
/******/ // Check if module is in cache | |
/******/ if(installedModules[moduleId]) { | |
/******/ return installedModules[moduleId].exports; | |
/******/ } | |
/******/ // Create a new module (and put it into the cache) | |
/******/ var module = installedModules[moduleId] = { | |
/******/ i: moduleId, | |
/******/ l: false, | |
/******/ exports: {} | |
/******/ }; | |
/******/ | |
/******/ // Execute the module function | |
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); | |
/******/ | |
/******/ // Flag the module as loaded | |
/******/ module.l = true; | |
/******/ | |
/******/ // Return the exports of the module | |
/******/ return module.exports; | |
/******/ } | |
/******/ | |
/******/ | |
/******/ // expose the modules object (__webpack_modules__) | |
/******/ __webpack_require__.m = modules; | |
/******/ | |
/******/ // expose the module cache | |
/******/ __webpack_require__.c = installedModules; | |
/******/ | |
/******/ // identity function for calling harmony imports with the correct context | |
/******/ __webpack_require__.i = function(value) { return value; }; | |
/******/ | |
/******/ // define getter function for harmony exports | |
/******/ __webpack_require__.d = function(exports, name, getter) { | |
/******/ if(!__webpack_require__.o(exports, name)) { | |
/******/ Object.defineProperty(exports, name, { | |
/******/ configurable: false, | |
/******/ enumerable: true, | |
/******/ get: getter | |
/******/ }); | |
/******/ } | |
/******/ }; | |
/******/ | |
/******/ // getDefaultExport function for compatibility with non-harmony modules | |
/******/ __webpack_require__.n = function(module) { | |
/******/ var getter = module && module.__esModule ? | |
/******/ function getDefault() { return module['default']; } : | |
/******/ function getModuleExports() { return module; }; | |
/******/ __webpack_require__.d(getter, 'a', getter); | |
/******/ return getter; | |
/******/ }; | |
/******/ | |
/******/ // Object.prototype.hasOwnProperty.call | |
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; | |
/******/ | |
/******/ // __webpack_public_path__ | |
/******/ __webpack_require__.p = "/build/build-es5/"; | |
/******/ | |
/******/ // Load entry module and return exports | |
/******/ return __webpack_require__(__webpack_require__.s = 64); | |
/******/ }) | |
/************************************************************************/ | |
/******/ ([ | |
/* 0 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// Thank's IE8 for his funny defineProperty | |
module.exports = !__webpack_require__(5)(function(){ | |
return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; | |
}); | |
/***/ }), | |
/* 1 */ | |
/***/ (function(module, exports) { | |
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 | |
var global = module.exports = typeof window != 'undefined' && window.Math == Math | |
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); | |
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef | |
/***/ }), | |
/* 2 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var anObject = __webpack_require__(8) | |
, IE8_DOM_DEFINE = __webpack_require__(23) | |
, toPrimitive = __webpack_require__(17) | |
, dP = Object.defineProperty; | |
exports.f = __webpack_require__(0) ? Object.defineProperty : function defineProperty(O, P, Attributes){ | |
anObject(O); | |
P = toPrimitive(P, true); | |
anObject(Attributes); | |
if(IE8_DOM_DEFINE)try { | |
return dP(O, P, Attributes); | |
} catch(e){ /* empty */ } | |
if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); | |
if('value' in Attributes)O[P] = Attributes.value; | |
return O; | |
}; | |
/***/ }), | |
/* 3 */ | |
/***/ (function(module, exports) { | |
var core = module.exports = {version: '2.4.0'}; | |
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef | |
/***/ }), | |
/* 4 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// to indexed object, toObject with fallback for non-array-like ES3 strings | |
var IObject = __webpack_require__(44) | |
, defined = __webpack_require__(21); | |
module.exports = function(it){ | |
return IObject(defined(it)); | |
}; | |
/***/ }), | |
/* 5 */ | |
/***/ (function(module, exports) { | |
module.exports = function(exec){ | |
try { | |
return !!exec(); | |
} catch(e){ | |
return true; | |
} | |
}; | |
/***/ }), | |
/* 6 */ | |
/***/ (function(module, exports) { | |
var hasOwnProperty = {}.hasOwnProperty; | |
module.exports = function(it, key){ | |
return hasOwnProperty.call(it, key); | |
}; | |
/***/ }), | |
/* 7 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 19.1.2.14 / 15.2.3.14 Object.keys(O) | |
var $keys = __webpack_require__(27) | |
, enumBugKeys = __webpack_require__(11); | |
module.exports = Object.keys || function keys(O){ | |
return $keys(O, enumBugKeys); | |
}; | |
/***/ }), | |
/* 8 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var isObject = __webpack_require__(9); | |
module.exports = function(it){ | |
if(!isObject(it))throw TypeError(it + ' is not an object!'); | |
return it; | |
}; | |
/***/ }), | |
/* 9 */ | |
/***/ (function(module, exports) { | |
module.exports = function(it){ | |
return typeof it === 'object' ? it !== null : typeof it === 'function'; | |
}; | |
/***/ }), | |
/* 10 */ | |
/***/ (function(module, exports) { | |
var id = 0 | |
, px = Math.random(); | |
module.exports = function(key){ | |
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); | |
}; | |
/***/ }), | |
/* 11 */ | |
/***/ (function(module, exports) { | |
// IE 8- don't enum bug keys | |
module.exports = ( | |
'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' | |
).split(','); | |
/***/ }), | |
/* 12 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var global = __webpack_require__(1) | |
, core = __webpack_require__(3) | |
, ctx = __webpack_require__(41) | |
, hide = __webpack_require__(13) | |
, PROTOTYPE = 'prototype'; | |
var $export = function(type, name, source){ | |
var IS_FORCED = type & $export.F | |
, IS_GLOBAL = type & $export.G | |
, IS_STATIC = type & $export.S | |
, IS_PROTO = type & $export.P | |
, IS_BIND = type & $export.B | |
, IS_WRAP = type & $export.W | |
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) | |
, expProto = exports[PROTOTYPE] | |
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] | |
, key, own, out; | |
if(IS_GLOBAL)source = name; | |
for(key in source){ | |
// contains in native | |
own = !IS_FORCED && target && target[key] !== undefined; | |
if(own && key in exports)continue; | |
// export native or passed | |
out = own ? target[key] : source[key]; | |
// prevent global pollution for namespaces | |
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] | |
// bind timers to global for call from export context | |
: IS_BIND && own ? ctx(out, global) | |
// wrap global constructors for prevent change them in library | |
: IS_WRAP && target[key] == out ? (function(C){ | |
var F = function(a, b, c){ | |
if(this instanceof C){ | |
switch(arguments.length){ | |
case 0: return new C; | |
case 1: return new C(a); | |
case 2: return new C(a, b); | |
} return new C(a, b, c); | |
} return C.apply(this, arguments); | |
}; | |
F[PROTOTYPE] = C[PROTOTYPE]; | |
return F; | |
// make static versions for prototype methods | |
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; | |
// export proto methods to core.%CONSTRUCTOR%.methods.%NAME% | |
if(IS_PROTO){ | |
(exports.virtual || (exports.virtual = {}))[key] = out; | |
// export proto methods to core.%CONSTRUCTOR%.prototype.%NAME% | |
if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out); | |
} | |
} | |
}; | |
// type bitmap | |
$export.F = 1; // forced | |
$export.G = 2; // global | |
$export.S = 4; // static | |
$export.P = 8; // proto | |
$export.B = 16; // bind | |
$export.W = 32; // wrap | |
$export.U = 64; // safe | |
$export.R = 128; // real proto method for `library` | |
module.exports = $export; | |
/***/ }), | |
/* 13 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var dP = __webpack_require__(2) | |
, createDesc = __webpack_require__(15); | |
module.exports = __webpack_require__(0) ? function(object, key, value){ | |
return dP.f(object, key, createDesc(1, value)); | |
} : function(object, key, value){ | |
object[key] = value; | |
return object; | |
}; | |
/***/ }), | |
/* 14 */ | |
/***/ (function(module, exports) { | |
exports.f = {}.propertyIsEnumerable; | |
/***/ }), | |
/* 15 */ | |
/***/ (function(module, exports) { | |
module.exports = function(bitmap, value){ | |
return { | |
enumerable : !(bitmap & 1), | |
configurable: !(bitmap & 2), | |
writable : !(bitmap & 4), | |
value : value | |
}; | |
}; | |
/***/ }), | |
/* 16 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var global = __webpack_require__(1) | |
, SHARED = '__core-js_shared__' | |
, store = global[SHARED] || (global[SHARED] = {}); | |
module.exports = function(key){ | |
return store[key] || (store[key] = {}); | |
}; | |
/***/ }), | |
/* 17 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 7.1.1 ToPrimitive(input [, PreferredType]) | |
var isObject = __webpack_require__(9); | |
// instead of the ES6 spec version, we didn't implement @@toPrimitive case | |
// and the second argument - flag - preferred type is a string | |
module.exports = function(it, S){ | |
if(!isObject(it))return it; | |
var fn, val; | |
if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; | |
if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val; | |
if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; | |
throw TypeError("Can't convert object to primitive value"); | |
}; | |
/***/ }), | |
/* 18 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var global = __webpack_require__(1) | |
, core = __webpack_require__(3) | |
, LIBRARY = __webpack_require__(24) | |
, wksExt = __webpack_require__(30) | |
, defineProperty = __webpack_require__(2).f; | |
module.exports = function(name){ | |
var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {}); | |
if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)}); | |
}; | |
/***/ }), | |
/* 19 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var store = __webpack_require__(16)('wks') | |
, uid = __webpack_require__(10) | |
, Symbol = __webpack_require__(1).Symbol | |
, USE_SYMBOL = typeof Symbol == 'function'; | |
var $exports = module.exports = function(name){ | |
return store[name] || (store[name] = | |
USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); | |
}; | |
$exports.store = store; | |
/***/ }), | |
/* 20 */ | |
/***/ (function(module, exports) { | |
var toString = {}.toString; | |
module.exports = function(it){ | |
return toString.call(it).slice(8, -1); | |
}; | |
/***/ }), | |
/* 21 */ | |
/***/ (function(module, exports) { | |
// 7.2.1 RequireObjectCoercible(argument) | |
module.exports = function(it){ | |
if(it == undefined)throw TypeError("Can't call method on " + it); | |
return it; | |
}; | |
/***/ }), | |
/* 22 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var isObject = __webpack_require__(9) | |
, document = __webpack_require__(1).document | |
// in old IE typeof document.createElement is 'object' | |
, is = isObject(document) && isObject(document.createElement); | |
module.exports = function(it){ | |
return is ? document.createElement(it) : {}; | |
}; | |
/***/ }), | |
/* 23 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = !__webpack_require__(0) && !__webpack_require__(5)(function(){ | |
return Object.defineProperty(__webpack_require__(22)('div'), 'a', {get: function(){ return 7; }}).a != 7; | |
}); | |
/***/ }), | |
/* 24 */ | |
/***/ (function(module, exports) { | |
module.exports = true; | |
/***/ }), | |
/* 25 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) | |
var $keys = __webpack_require__(27) | |
, hiddenKeys = __webpack_require__(11).concat('length', 'prototype'); | |
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){ | |
return $keys(O, hiddenKeys); | |
}; | |
/***/ }), | |
/* 26 */ | |
/***/ (function(module, exports) { | |
exports.f = Object.getOwnPropertySymbols; | |
/***/ }), | |
/* 27 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var has = __webpack_require__(6) | |
, toIObject = __webpack_require__(4) | |
, arrayIndexOf = __webpack_require__(40)(false) | |
, IE_PROTO = __webpack_require__(28)('IE_PROTO'); | |
module.exports = function(object, names){ | |
var O = toIObject(object) | |
, i = 0 | |
, result = [] | |
, key; | |
for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key); | |
// Don't enum bug & hidden keys | |
while(names.length > i)if(has(O, key = names[i++])){ | |
~arrayIndexOf(result, key) || result.push(key); | |
} | |
return result; | |
}; | |
/***/ }), | |
/* 28 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var shared = __webpack_require__(16)('keys') | |
, uid = __webpack_require__(10); | |
module.exports = function(key){ | |
return shared[key] || (shared[key] = uid(key)); | |
}; | |
/***/ }), | |
/* 29 */ | |
/***/ (function(module, exports) { | |
// 7.1.4 ToInteger | |
var ceil = Math.ceil | |
, floor = Math.floor; | |
module.exports = function(it){ | |
return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); | |
}; | |
/***/ }), | |
/* 30 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
exports.f = __webpack_require__(19); | |
/***/ }), | |
/* 31 */ | |
/***/ (function(module, __webpack_exports__, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_define_property__ = __webpack_require__(33); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_define_property___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_define_property__); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_keys__ = __webpack_require__(34); | |
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_keys___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_keys__); | |
Object.defineProperty(exports, "__esModule", { | |
value: true | |
}); | |
var _common = __webpack_require__(32); | |
__WEBPACK_IMPORTED_MODULE_1_babel_runtime_core_js_object_keys___default()(_common).forEach(function (key) { | |
if (key === "default" || key === "__esModule") return; | |
__WEBPACK_IMPORTED_MODULE_0_babel_runtime_core_js_object_define_property___default()(exports, key, { | |
enumerable: true, | |
get: function get() { | |
return _common[key]; | |
} | |
}); | |
}); | |
/***/ }), | |
/* 32 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { | |
value: true | |
}); | |
exports.TESTSYMBOL2 = exports.TESTSYMBOL = undefined; | |
var _symbol = __webpack_require__(35); | |
var _symbol2 = _interopRequireDefault(_symbol); | |
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
var TESTSYMBOL = exports.TESTSYMBOL = (0, _symbol2.default)('test'); | |
var TESTSYMBOL2 = exports.TESTSYMBOL2 = (0, _symbol2.default)('test2'); | |
/***/ }), | |
/* 33 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = { "default": __webpack_require__(36), __esModule: true }; | |
/***/ }), | |
/* 34 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = { "default": __webpack_require__(37), __esModule: true }; | |
/***/ }), | |
/* 35 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = { "default": __webpack_require__(38), __esModule: true }; | |
/***/ }), | |
/* 36 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
__webpack_require__(58); | |
var $Object = __webpack_require__(3).Object; | |
module.exports = function defineProperty(it, key, desc){ | |
return $Object.defineProperty(it, key, desc); | |
}; | |
/***/ }), | |
/* 37 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
__webpack_require__(59); | |
module.exports = __webpack_require__(3).Object.keys; | |
/***/ }), | |
/* 38 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
__webpack_require__(61); | |
__webpack_require__(60); | |
__webpack_require__(62); | |
__webpack_require__(63); | |
module.exports = __webpack_require__(3).Symbol; | |
/***/ }), | |
/* 39 */ | |
/***/ (function(module, exports) { | |
module.exports = function(it){ | |
if(typeof it != 'function')throw TypeError(it + ' is not a function!'); | |
return it; | |
}; | |
/***/ }), | |
/* 40 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// false -> Array#indexOf | |
// true -> Array#includes | |
var toIObject = __webpack_require__(4) | |
, toLength = __webpack_require__(56) | |
, toIndex = __webpack_require__(55); | |
module.exports = function(IS_INCLUDES){ | |
return function($this, el, fromIndex){ | |
var O = toIObject($this) | |
, length = toLength(O.length) | |
, index = toIndex(fromIndex, length) | |
, value; | |
// Array#includes uses SameValueZero equality algorithm | |
if(IS_INCLUDES && el != el)while(length > index){ | |
value = O[index++]; | |
if(value != value)return true; | |
// Array#toIndex ignores holes, Array#includes - not | |
} else for(;length > index; index++)if(IS_INCLUDES || index in O){ | |
if(O[index] === el)return IS_INCLUDES || index || 0; | |
} return !IS_INCLUDES && -1; | |
}; | |
}; | |
/***/ }), | |
/* 41 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// optional / simple context binding | |
var aFunction = __webpack_require__(39); | |
module.exports = function(fn, that, length){ | |
aFunction(fn); | |
if(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(/* ...args */){ | |
return fn.apply(that, arguments); | |
}; | |
}; | |
/***/ }), | |
/* 42 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// all enumerable object keys, includes symbols | |
var getKeys = __webpack_require__(7) | |
, gOPS = __webpack_require__(26) | |
, pIE = __webpack_require__(14); | |
module.exports = function(it){ | |
var result = getKeys(it) | |
, getSymbols = gOPS.f; | |
if(getSymbols){ | |
var symbols = getSymbols(it) | |
, isEnum = pIE.f | |
, i = 0 | |
, key; | |
while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key); | |
} return result; | |
}; | |
/***/ }), | |
/* 43 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = __webpack_require__(1).document && document.documentElement; | |
/***/ }), | |
/* 44 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// fallback for non-array-like ES3 and non-enumerable old V8 strings | |
var cof = __webpack_require__(20); | |
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ | |
return cof(it) == 'String' ? it.split('') : Object(it); | |
}; | |
/***/ }), | |
/* 45 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 7.2.2 IsArray(argument) | |
var cof = __webpack_require__(20); | |
module.exports = Array.isArray || function isArray(arg){ | |
return cof(arg) == 'Array'; | |
}; | |
/***/ }), | |
/* 46 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var getKeys = __webpack_require__(7) | |
, toIObject = __webpack_require__(4); | |
module.exports = function(object, el){ | |
var O = toIObject(object) | |
, keys = getKeys(O) | |
, length = keys.length | |
, index = 0 | |
, key; | |
while(length > index)if(O[key = keys[index++]] === el)return key; | |
}; | |
/***/ }), | |
/* 47 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var META = __webpack_require__(10)('meta') | |
, isObject = __webpack_require__(9) | |
, has = __webpack_require__(6) | |
, setDesc = __webpack_require__(2).f | |
, id = 0; | |
var isExtensible = Object.isExtensible || function(){ | |
return true; | |
}; | |
var FREEZE = !__webpack_require__(5)(function(){ | |
return isExtensible(Object.preventExtensions({})); | |
}); | |
var setMeta = function(it){ | |
setDesc(it, META, {value: { | |
i: 'O' + ++id, // object ID | |
w: {} // weak collections IDs | |
}}); | |
}; | |
var fastKey = function(it, create){ | |
// return primitive with prefix | |
if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; | |
if(!has(it, META)){ | |
// can't set metadata to uncaught frozen object | |
if(!isExtensible(it))return 'F'; | |
// not necessary to add metadata | |
if(!create)return 'E'; | |
// add missing metadata | |
setMeta(it); | |
// return object ID | |
} return it[META].i; | |
}; | |
var getWeak = function(it, create){ | |
if(!has(it, META)){ | |
// can't set metadata to uncaught frozen object | |
if(!isExtensible(it))return true; | |
// not necessary to add metadata | |
if(!create)return false; | |
// add missing metadata | |
setMeta(it); | |
// return hash weak collections IDs | |
} return it[META].w; | |
}; | |
// add metadata on freeze-family methods calling | |
var onFreeze = function(it){ | |
if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it); | |
return it; | |
}; | |
var meta = module.exports = { | |
KEY: META, | |
NEED: false, | |
fastKey: fastKey, | |
getWeak: getWeak, | |
onFreeze: onFreeze | |
}; | |
/***/ }), | |
/* 48 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) | |
var anObject = __webpack_require__(8) | |
, dPs = __webpack_require__(49) | |
, enumBugKeys = __webpack_require__(11) | |
, IE_PROTO = __webpack_require__(28)('IE_PROTO') | |
, Empty = function(){ /* empty */ } | |
, PROTOTYPE = 'prototype'; | |
// Create object with fake `null` prototype: use iframe Object with cleared prototype | |
var createDict = function(){ | |
// Thrash, waste and sodomy: IE GC bug | |
var iframe = __webpack_require__(22)('iframe') | |
, i = enumBugKeys.length | |
, lt = '<' | |
, gt = '>' | |
, iframeDocument; | |
iframe.style.display = 'none'; | |
__webpack_require__(43).appendChild(iframe); | |
iframe.src = 'javascript:'; // eslint-disable-line no-script-url | |
// createDict = iframe.contentWindow.Object; | |
// html.removeChild(iframe); | |
iframeDocument = iframe.contentWindow.document; | |
iframeDocument.open(); | |
iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); | |
iframeDocument.close(); | |
createDict = iframeDocument.F; | |
while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]]; | |
return createDict(); | |
}; | |
module.exports = Object.create || function create(O, Properties){ | |
var result; | |
if(O !== null){ | |
Empty[PROTOTYPE] = anObject(O); | |
result = new Empty; | |
Empty[PROTOTYPE] = null; | |
// add "__proto__" for Object.getPrototypeOf polyfill | |
result[IE_PROTO] = O; | |
} else result = createDict(); | |
return Properties === undefined ? result : dPs(result, Properties); | |
}; | |
/***/ }), | |
/* 49 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var dP = __webpack_require__(2) | |
, anObject = __webpack_require__(8) | |
, getKeys = __webpack_require__(7); | |
module.exports = __webpack_require__(0) ? Object.defineProperties : function defineProperties(O, Properties){ | |
anObject(O); | |
var keys = getKeys(Properties) | |
, length = keys.length | |
, i = 0 | |
, P; | |
while(length > i)dP.f(O, P = keys[i++], Properties[P]); | |
return O; | |
}; | |
/***/ }), | |
/* 50 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var pIE = __webpack_require__(14) | |
, createDesc = __webpack_require__(15) | |
, toIObject = __webpack_require__(4) | |
, toPrimitive = __webpack_require__(17) | |
, has = __webpack_require__(6) | |
, IE8_DOM_DEFINE = __webpack_require__(23) | |
, gOPD = Object.getOwnPropertyDescriptor; | |
exports.f = __webpack_require__(0) ? gOPD : function getOwnPropertyDescriptor(O, P){ | |
O = toIObject(O); | |
P = toPrimitive(P, true); | |
if(IE8_DOM_DEFINE)try { | |
return gOPD(O, P); | |
} catch(e){ /* empty */ } | |
if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]); | |
}; | |
/***/ }), | |
/* 51 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window | |
var toIObject = __webpack_require__(4) | |
, gOPN = __webpack_require__(25).f | |
, toString = {}.toString; | |
var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames | |
? Object.getOwnPropertyNames(window) : []; | |
var getWindowNames = function(it){ | |
try { | |
return gOPN(it); | |
} catch(e){ | |
return windowNames.slice(); | |
} | |
}; | |
module.exports.f = function getOwnPropertyNames(it){ | |
return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it)); | |
}; | |
/***/ }), | |
/* 52 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// most Object methods by ES6 should accept primitives | |
var $export = __webpack_require__(12) | |
, core = __webpack_require__(3) | |
, fails = __webpack_require__(5); | |
module.exports = function(KEY, exec){ | |
var fn = (core.Object || {})[KEY] || Object[KEY] | |
, exp = {}; | |
exp[KEY] = exec(fn); | |
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp); | |
}; | |
/***/ }), | |
/* 53 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = __webpack_require__(13); | |
/***/ }), | |
/* 54 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var def = __webpack_require__(2).f | |
, has = __webpack_require__(6) | |
, TAG = __webpack_require__(19)('toStringTag'); | |
module.exports = function(it, tag, stat){ | |
if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag}); | |
}; | |
/***/ }), | |
/* 55 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var toInteger = __webpack_require__(29) | |
, max = Math.max | |
, min = Math.min; | |
module.exports = function(index, length){ | |
index = toInteger(index); | |
return index < 0 ? max(index + length, 0) : min(index, length); | |
}; | |
/***/ }), | |
/* 56 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 7.1.15 ToLength | |
var toInteger = __webpack_require__(29) | |
, min = Math.min; | |
module.exports = function(it){ | |
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 | |
}; | |
/***/ }), | |
/* 57 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 7.1.13 ToObject(argument) | |
var defined = __webpack_require__(21); | |
module.exports = function(it){ | |
return Object(defined(it)); | |
}; | |
/***/ }), | |
/* 58 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
var $export = __webpack_require__(12); | |
// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) | |
$export($export.S + $export.F * !__webpack_require__(0), 'Object', {defineProperty: __webpack_require__(2).f}); | |
/***/ }), | |
/* 59 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
// 19.1.2.14 Object.keys(O) | |
var toObject = __webpack_require__(57) | |
, $keys = __webpack_require__(7); | |
__webpack_require__(52)('keys', function(){ | |
return function keys(it){ | |
return $keys(toObject(it)); | |
}; | |
}); | |
/***/ }), | |
/* 60 */ | |
/***/ (function(module, exports) { | |
/***/ }), | |
/* 61 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
"use strict"; | |
// ECMAScript 6 symbols shim | |
var global = __webpack_require__(1) | |
, has = __webpack_require__(6) | |
, DESCRIPTORS = __webpack_require__(0) | |
, $export = __webpack_require__(12) | |
, redefine = __webpack_require__(53) | |
, META = __webpack_require__(47).KEY | |
, $fails = __webpack_require__(5) | |
, shared = __webpack_require__(16) | |
, setToStringTag = __webpack_require__(54) | |
, uid = __webpack_require__(10) | |
, wks = __webpack_require__(19) | |
, wksExt = __webpack_require__(30) | |
, wksDefine = __webpack_require__(18) | |
, keyOf = __webpack_require__(46) | |
, enumKeys = __webpack_require__(42) | |
, isArray = __webpack_require__(45) | |
, anObject = __webpack_require__(8) | |
, toIObject = __webpack_require__(4) | |
, toPrimitive = __webpack_require__(17) | |
, createDesc = __webpack_require__(15) | |
, _create = __webpack_require__(48) | |
, gOPNExt = __webpack_require__(51) | |
, $GOPD = __webpack_require__(50) | |
, $DP = __webpack_require__(2) | |
, $keys = __webpack_require__(7) | |
, gOPD = $GOPD.f | |
, dP = $DP.f | |
, gOPN = gOPNExt.f | |
, $Symbol = global.Symbol | |
, $JSON = global.JSON | |
, _stringify = $JSON && $JSON.stringify | |
, PROTOTYPE = 'prototype' | |
, HIDDEN = wks('_hidden') | |
, TO_PRIMITIVE = wks('toPrimitive') | |
, isEnum = {}.propertyIsEnumerable | |
, SymbolRegistry = shared('symbol-registry') | |
, AllSymbols = shared('symbols') | |
, OPSymbols = shared('op-symbols') | |
, ObjectProto = Object[PROTOTYPE] | |
, USE_NATIVE = typeof $Symbol == 'function' | |
, QObject = global.QObject; | |
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 | |
var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; | |
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 | |
var setSymbolDesc = DESCRIPTORS && $fails(function(){ | |
return _create(dP({}, 'a', { | |
get: function(){ return dP(this, 'a', {value: 7}).a; } | |
})).a != 7; | |
}) ? function(it, key, D){ | |
var protoDesc = gOPD(ObjectProto, key); | |
if(protoDesc)delete ObjectProto[key]; | |
dP(it, key, D); | |
if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc); | |
} : dP; | |
var wrap = function(tag){ | |
var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); | |
sym._k = tag; | |
return sym; | |
}; | |
var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){ | |
return typeof it == 'symbol'; | |
} : function(it){ | |
return it instanceof $Symbol; | |
}; | |
var $defineProperty = function defineProperty(it, key, D){ | |
if(it === ObjectProto)$defineProperty(OPSymbols, key, D); | |
anObject(it); | |
key = toPrimitive(key, true); | |
anObject(D); | |
if(has(AllSymbols, key)){ | |
if(!D.enumerable){ | |
if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {})); | |
it[HIDDEN][key] = true; | |
} else { | |
if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false; | |
D = _create(D, {enumerable: createDesc(0, false)}); | |
} return setSymbolDesc(it, key, D); | |
} return dP(it, key, D); | |
}; | |
var $defineProperties = function defineProperties(it, P){ | |
anObject(it); | |
var keys = enumKeys(P = toIObject(P)) | |
, i = 0 | |
, l = keys.length | |
, key; | |
while(l > i)$defineProperty(it, key = keys[i++], P[key]); | |
return it; | |
}; | |
var $create = function create(it, P){ | |
return P === undefined ? _create(it) : $defineProperties(_create(it), P); | |
}; | |
var $propertyIsEnumerable = function propertyIsEnumerable(key){ | |
var E = isEnum.call(this, key = toPrimitive(key, true)); | |
if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false; | |
return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; | |
}; | |
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){ | |
it = toIObject(it); | |
key = toPrimitive(key, true); | |
if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return; | |
var D = gOPD(it, key); | |
if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true; | |
return D; | |
}; | |
var $getOwnPropertyNames = function getOwnPropertyNames(it){ | |
var names = gOPN(toIObject(it)) | |
, result = [] | |
, i = 0 | |
, key; | |
while(names.length > i){ | |
if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key); | |
} return result; | |
}; | |
var $getOwnPropertySymbols = function getOwnPropertySymbols(it){ | |
var IS_OP = it === ObjectProto | |
, names = gOPN(IS_OP ? OPSymbols : toIObject(it)) | |
, result = [] | |
, i = 0 | |
, key; | |
while(names.length > i){ | |
if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]); | |
} return result; | |
}; | |
// 19.4.1.1 Symbol([description]) | |
if(!USE_NATIVE){ | |
$Symbol = function Symbol(){ | |
if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!'); | |
var tag = uid(arguments.length > 0 ? arguments[0] : undefined); | |
var $set = function(value){ | |
if(this === ObjectProto)$set.call(OPSymbols, value); | |
if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false; | |
setSymbolDesc(this, tag, createDesc(1, value)); | |
}; | |
if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set}); | |
return wrap(tag); | |
}; | |
redefine($Symbol[PROTOTYPE], 'toString', function toString(){ | |
return this._k; | |
}); | |
$GOPD.f = $getOwnPropertyDescriptor; | |
$DP.f = $defineProperty; | |
__webpack_require__(25).f = gOPNExt.f = $getOwnPropertyNames; | |
__webpack_require__(14).f = $propertyIsEnumerable; | |
__webpack_require__(26).f = $getOwnPropertySymbols; | |
if(DESCRIPTORS && !__webpack_require__(24)){ | |
redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); | |
} | |
wksExt.f = function(name){ | |
return wrap(wks(name)); | |
} | |
} | |
$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol}); | |
for(var symbols = ( | |
// 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 | |
'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables' | |
).split(','), i = 0; symbols.length > i; )wks(symbols[i++]); | |
for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]); | |
$export($export.S + $export.F * !USE_NATIVE, 'Symbol', { | |
// 19.4.2.1 Symbol.for(key) | |
'for': function(key){ | |
return has(SymbolRegistry, key += '') | |
? SymbolRegistry[key] | |
: SymbolRegistry[key] = $Symbol(key); | |
}, | |
// 19.4.2.5 Symbol.keyFor(sym) | |
keyFor: function keyFor(key){ | |
if(isSymbol(key))return keyOf(SymbolRegistry, key); | |
throw TypeError(key + ' is not a symbol!'); | |
}, | |
useSetter: function(){ setter = true; }, | |
useSimple: function(){ setter = false; } | |
}); | |
$export($export.S + $export.F * !USE_NATIVE, 'Object', { | |
// 19.1.2.2 Object.create(O [, Properties]) | |
create: $create, | |
// 19.1.2.4 Object.defineProperty(O, P, Attributes) | |
defineProperty: $defineProperty, | |
// 19.1.2.3 Object.defineProperties(O, Properties) | |
defineProperties: $defineProperties, | |
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) | |
getOwnPropertyDescriptor: $getOwnPropertyDescriptor, | |
// 19.1.2.7 Object.getOwnPropertyNames(O) | |
getOwnPropertyNames: $getOwnPropertyNames, | |
// 19.1.2.8 Object.getOwnPropertySymbols(O) | |
getOwnPropertySymbols: $getOwnPropertySymbols | |
}); | |
// 24.3.2 JSON.stringify(value [, replacer [, space]]) | |
$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){ | |
var S = $Symbol(); | |
// MS Edge converts symbol values to JSON as {} | |
// WebKit converts symbol values to JSON as null | |
// V8 throws on boxed symbols | |
return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}'; | |
})), 'JSON', { | |
stringify: function stringify(it){ | |
if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined | |
var args = [it] | |
, i = 1 | |
, replacer, $replacer; | |
while(arguments.length > i)args.push(arguments[i++]); | |
replacer = args[1]; | |
if(typeof replacer == 'function')$replacer = replacer; | |
if($replacer || !isArray(replacer))replacer = function(key, value){ | |
if($replacer)value = $replacer.call(this, key, value); | |
if(!isSymbol(value))return value; | |
}; | |
args[1] = replacer; | |
return _stringify.apply($JSON, args); | |
} | |
}); | |
// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) | |
$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(13)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); | |
// 19.4.3.5 Symbol.prototype[@@toStringTag] | |
setToStringTag($Symbol, 'Symbol'); | |
// 20.2.1.9 Math[@@toStringTag] | |
setToStringTag(Math, 'Math', true); | |
// 24.3.3 JSON[@@toStringTag] | |
setToStringTag(global.JSON, 'JSON', true); | |
/***/ }), | |
/* 62 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
__webpack_require__(18)('asyncIterator'); | |
/***/ }), | |
/* 63 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
__webpack_require__(18)('observable'); | |
/***/ }), | |
/* 64 */ | |
/***/ (function(module, exports, __webpack_require__) { | |
module.exports = __webpack_require__(31); | |
/***/ }) | |
/******/ ]); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment