/*eslint no-unused-vars: 0*/ /*eslint strict: 0*/ var $buoop = { vs: {i:9, f:25, o:12.1, s:7}, c:2 }; function $buo_f(){ var e = document.createElement('script'); e.src = '//browser-update.org/update.min.js'; document.body.appendChild(e); } try {document.addEventListener('DOMContentLoaded', $buo_f, false);} catch(e){window.attachEvent('onload', $buo_f);} /******/ (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] = { /******/ exports: {}, /******/ id: moduleId, /******/ loaded: false /******/ }; /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ // Flag the module as loaded /******/ module.loaded = 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; /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ // Load entry module and return exports /******/ return __webpack_require__(0); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(global) {"use strict"; __webpack_require__(1); var event_target_1 = __webpack_require__(2); var define_property_1 = __webpack_require__(4); var register_element_1 = __webpack_require__(5); var property_descriptor_1 = __webpack_require__(6); var timers_1 = __webpack_require__(8); var utils_1 = __webpack_require__(3); var set = 'set'; var clear = 'clear'; var blockingMethods = ['alert', 'prompt', 'confirm']; var _global = typeof window == 'undefined' ? global : window; timers_1.patchTimer(_global, set, clear, 'Timeout'); timers_1.patchTimer(_global, set, clear, 'Interval'); timers_1.patchTimer(_global, set, clear, 'Immediate'); timers_1.patchTimer(_global, 'request', 'cancelMacroTask', 'AnimationFrame'); timers_1.patchTimer(_global, 'mozRequest', 'mozCancel', 'AnimationFrame'); timers_1.patchTimer(_global, 'webkitRequest', 'webkitCancel', 'AnimationFrame'); for (var i = 0; i < blockingMethods.length; i++) { var name = blockingMethods[i]; utils_1.patchMethod(_global, name, function (delegate, symbol, name) { return function (s, args) { return Zone.current.run(delegate, _global, args, name); }; }); } event_target_1.eventTargetPatch(_global); property_descriptor_1.propertyDescriptorPatch(_global); utils_1.patchClass('MutationObserver'); utils_1.patchClass('WebKitMutationObserver'); utils_1.patchClass('FileReader'); define_property_1.propertyPatch(); register_element_1.registerElementPatch(_global); // Treat XMLHTTPRequest as a macrotask. patchXHR(_global); var XHR_TASK = utils_1.zoneSymbol('xhrTask'); function patchXHR(window) { function findPendingTask(target) { var pendingTask = target[XHR_TASK]; return pendingTask; } function scheduleTask(task) { var data = task.data; data.target.addEventListener('readystatechange', function () { if (data.target.readyState === XMLHttpRequest.DONE) { if (!data.aborted) { task.invoke(); } } }); var storedTask = data.target[XHR_TASK]; if (!storedTask) { data.target[XHR_TASK] = task; } setNative.apply(data.target, data.args); return task; } function placeholderCallback() { } function clearTask(task) { var data = task.data; // Note - ideally, we would call data.target.removeEventListener here, but it's too late // to prevent it from firing. So instead, we store info for the event listener. data.aborted = true; return clearNative.apply(data.target, data.args); } var setNative = utils_1.patchMethod(window.XMLHttpRequest.prototype, 'send', function () { return function (self, args) { var zone = Zone.current; var options = { target: self, isPeriodic: false, delay: null, args: args, aborted: false }; return zone.scheduleMacroTask('XMLHttpRequest.send', placeholderCallback, options, scheduleTask, clearTask); }; }); var clearNative = utils_1.patchMethod(window.XMLHttpRequest.prototype, 'abort', function (delegate) { return function (self, args) { var task = findPendingTask(self); if (task && typeof task.type == 'string') { // If the XHR has already completed, do nothing. if (task.cancelFn == null) { return; } task.zone.cancelTask(task); } // Otherwise, we are trying to abort an XHR which has not yet been sent, so there is no task to cancel. Do nothing. }; }); } /// GEO_LOCATION if (_global['navigator'] && _global['navigator'].geolocation) { utils_1.patchPrototype(_global['navigator'].geolocation, [ 'getCurrentPosition', 'watchPosition' ]); } /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) /***/ }, /* 1 */ /***/ function(module, exports) { /* WEBPACK VAR INJECTION */(function(global) {; ; var Zone = (function (global) { var Zone = (function () { function Zone(parent, zoneSpec) { this._properties = null; this._parent = parent; this._name = zoneSpec ? zoneSpec.name || 'unnamed' : ''; this._properties = zoneSpec && zoneSpec.properties || {}; this._zoneDelegate = new ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec); } Object.defineProperty(Zone, "current", { get: function () { return _currentZone; }, enumerable: true, configurable: true }); ; Object.defineProperty(Zone, "currentTask", { get: function () { return _currentTask; }, enumerable: true, configurable: true }); ; Object.defineProperty(Zone.prototype, "parent", { get: function () { return this._parent; }, enumerable: true, configurable: true }); ; Object.defineProperty(Zone.prototype, "name", { get: function () { return this._name; }, enumerable: true, configurable: true }); ; Zone.prototype.get = function (key) { var current = this; while (current) { if (current._properties.hasOwnProperty(key)) { return current._properties[key]; } current = current._parent; } }; Zone.prototype.fork = function (zoneSpec) { if (!zoneSpec) throw new Error('ZoneSpec required!'); return this._zoneDelegate.fork(this, zoneSpec); }; Zone.prototype.wrap = function (callback, source) { if (typeof callback !== 'function') { throw new Error('Expecting function got: ' + callback); } var _callback = this._zoneDelegate.intercept(this, callback, source); var zone = this; return function () { return zone.runGuarded(_callback, this, arguments, source); }; }; Zone.prototype.run = function (callback, applyThis, applyArgs, source) { if (applyThis === void 0) { applyThis = null; } if (applyArgs === void 0) { applyArgs = null; } if (source === void 0) { source = null; } var oldZone = _currentZone; _currentZone = this; try { return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); } finally { _currentZone = oldZone; } }; Zone.prototype.runGuarded = function (callback, applyThis, applyArgs, source) { if (applyThis === void 0) { applyThis = null; } if (applyArgs === void 0) { applyArgs = null; } if (source === void 0) { source = null; } var oldZone = _currentZone; _currentZone = this; try { try { return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source); } catch (error) { if (this._zoneDelegate.handleError(this, error)) { throw error; } } } finally { _currentZone = oldZone; } }; Zone.prototype.runTask = function (task, applyThis, applyArgs) { task.runCount++; if (task.zone != this) throw new Error('A task can only be run in the zone which created it! (Creation: ' + task.zone.name + '; Execution: ' + this.name + ')'); var previousTask = _currentTask; _currentTask = task; var oldZone = _currentZone; _currentZone = this; try { if (task.type == 'macroTask' && task.data && !task.data.isPeriodic) { task.cancelFn = null; } try { return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs); } catch (error) { if (this._zoneDelegate.handleError(this, error)) { throw error; } } } finally { _currentZone = oldZone; _currentTask = previousTask; } }; Zone.prototype.scheduleMicroTask = function (source, callback, data, customSchedule) { return this._zoneDelegate.scheduleTask(this, new ZoneTask('microTask', this, source, callback, data, customSchedule, null)); }; Zone.prototype.scheduleMacroTask = function (source, callback, data, customSchedule, customCancel) { return this._zoneDelegate.scheduleTask(this, new ZoneTask('macroTask', this, source, callback, data, customSchedule, customCancel)); }; Zone.prototype.scheduleEventTask = function (source, callback, data, customSchedule, customCancel) { return this._zoneDelegate.scheduleTask(this, new ZoneTask('eventTask', this, source, callback, data, customSchedule, customCancel)); }; Zone.prototype.cancelTask = function (task) { var value = this._zoneDelegate.cancelTask(this, task); task.runCount = -1; task.cancelFn = null; return value; }; Zone.__symbol__ = __symbol__; return Zone; }()); ; var ZoneDelegate = (function () { function ZoneDelegate(zone, parentDelegate, zoneSpec) { this._taskCounts = { microTask: 0, macroTask: 0, eventTask: 0 }; this.zone = zone; this._parentDelegate = parentDelegate; this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS); this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt); this._interceptZS = zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS); this._interceptDlgt = zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt); this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS); this._invokeDlgt = zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt); this._handleErrorZS = zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS); this._handleErrorDlgt = zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt); this._scheduleTaskZS = zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS); this._scheduleTaskDlgt = zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt); this._invokeTaskZS = zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS); this._invokeTaskDlgt = zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt); this._cancelTaskZS = zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS); this._cancelTaskDlgt = zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt); this._hasTaskZS = zoneSpec && (zoneSpec.onHasTask ? zoneSpec : parentDelegate._hasTaskZS); this._hasTaskDlgt = zoneSpec && (zoneSpec.onHasTask ? parentDelegate : parentDelegate._hasTaskDlgt); } ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) { return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) : new Zone(targetZone, zoneSpec); }; ZoneDelegate.prototype.intercept = function (targetZone, callback, source) { return this._interceptZS ? this._interceptZS.onIntercept(this._interceptDlgt, this.zone, targetZone, callback, source) : callback; }; ZoneDelegate.prototype.invoke = function (targetZone, callback, applyThis, applyArgs, source) { return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this.zone, targetZone, callback, applyThis, applyArgs, source) : callback.apply(applyThis, applyArgs); }; ZoneDelegate.prototype.handleError = function (targetZone, error) { return this._handleErrorZS ? this._handleErrorZS.onHandleError(this._handleErrorDlgt, this.zone, targetZone, error) : true; }; ZoneDelegate.prototype.scheduleTask = function (targetZone, task) { try { if (this._scheduleTaskZS) { return this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this.zone, targetZone, task); } else if (task.scheduleFn) { task.scheduleFn(task); } else if (task.type == 'microTask') { scheduleMicroTask(task); } else { throw new Error('Task is missing scheduleFn.'); } return task; } finally { if (targetZone == this.zone) { this._updateTaskCount(task.type, 1); } } }; ZoneDelegate.prototype.invokeTask = function (targetZone, task, applyThis, applyArgs) { try { return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this.zone, targetZone, task, applyThis, applyArgs) : task.callback.apply(applyThis, applyArgs); } finally { if (targetZone == this.zone && (task.type != 'eventTask') && !(task.data && task.data.isPeriodic)) { this._updateTaskCount(task.type, -1); } } }; ZoneDelegate.prototype.cancelTask = function (targetZone, task) { var value; if (this._cancelTaskZS) { value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this.zone, targetZone, task); } else if (!task.cancelFn) { throw new Error('Task does not support cancellation, or is already canceled.'); } else { value = task.cancelFn(task); } if (targetZone == this.zone) { // this should not be in the finally block, because exceptions assume not canceled. this._updateTaskCount(task.type, -1); } return value; }; ZoneDelegate.prototype.hasTask = function (targetZone, isEmpty) { return this._hasTaskZS && this._hasTaskZS.onHasTask(this._hasTaskDlgt, this.zone, targetZone, isEmpty); }; ZoneDelegate.prototype._updateTaskCount = function (type, count) { var counts = this._taskCounts; var prev = counts[type]; var next = counts[type] = prev + count; if (next < 0) { throw new Error('More tasks executed then were scheduled.'); } if (prev == 0 || next == 0) { var isEmpty = { microTask: counts.microTask > 0, macroTask: counts.macroTask > 0, eventTask: counts.eventTask > 0, change: type }; try { this.hasTask(this.zone, isEmpty); } finally { if (this._parentDelegate) { this._parentDelegate._updateTaskCount(type, count); } } } }; return ZoneDelegate; }()); var ZoneTask = (function () { function ZoneTask(type, zone, source, callback, options, scheduleFn, cancelFn) { this.runCount = 0; this.type = type; this.zone = zone; this.source = source; this.data = options; this.scheduleFn = scheduleFn; this.cancelFn = cancelFn; this.callback = callback; var self = this; this.invoke = function () { try { return zone.runTask(self, this, arguments); } finally { drainMicroTaskQueue(); } }; } return ZoneTask; }()); function __symbol__(name) { return '__zone_symbol__' + name; } ; var symbolSetTimeout = __symbol__('setTimeout'); var symbolPromise = __symbol__('Promise'); var symbolThen = __symbol__('then'); var _currentZone = new Zone(null, null); var _currentTask = null; var _microTaskQueue = []; var _isDrainingMicrotaskQueue = false; var _uncaughtPromiseErrors = []; var _drainScheduled = false; function scheduleQueueDrain() { if (!_drainScheduled && !_currentTask && _microTaskQueue.length == 0) { // We are not running in Task, so we need to kickstart the microtask queue. if (global[symbolPromise]) { global[symbolPromise].resolve(0)[symbolThen](drainMicroTaskQueue); } else { global[symbolSetTimeout](drainMicroTaskQueue, 0); } } } function scheduleMicroTask(task) { scheduleQueueDrain(); _microTaskQueue.push(task); } function consoleError(e) { var rejection = e && e.rejection; if (rejection) { console.error('Unhandled Promise rejection:', rejection instanceof Error ? rejection.message : rejection, '; Zone:', e.zone.name, '; Task:', e.task && e.task.source, '; Value:', rejection); } console.error(e); } function drainMicroTaskQueue() { if (!_isDrainingMicrotaskQueue) { _isDrainingMicrotaskQueue = true; while (_microTaskQueue.length) { var queue = _microTaskQueue; _microTaskQueue = []; for (var i = 0; i < queue.length; i++) { var task = queue[i]; try { task.zone.runTask(task, null, null); } catch (e) { consoleError(e); } } } while (_uncaughtPromiseErrors.length) { var uncaughtPromiseErrors = _uncaughtPromiseErrors; _uncaughtPromiseErrors = []; var _loop_1 = function(i) { var uncaughtPromiseError = uncaughtPromiseErrors[i]; try { uncaughtPromiseError.zone.runGuarded(function () { throw uncaughtPromiseError; }); } catch (e) { consoleError(e); } }; for (var i = 0; i < uncaughtPromiseErrors.length; i++) { _loop_1(i); } } _isDrainingMicrotaskQueue = false; _drainScheduled = false; } } function isThenable(value) { return value && value.then; } function forwardResolution(value) { return value; } function forwardRejection(rejection) { return ZoneAwarePromise.reject(rejection); } var symbolState = __symbol__('state'); var symbolValue = __symbol__('value'); var source = 'Promise.then'; var UNRESOLVED = null; var RESOLVED = true; var REJECTED = false; var REJECTED_NO_CATCH = 0; function makeResolver(promise, state) { return function (v) { resolvePromise(promise, state, v); // Do not return value or you will break the Promise spec. }; } function resolvePromise(promise, state, value) { if (promise[symbolState] === UNRESOLVED) { if (value instanceof ZoneAwarePromise && value[symbolState] !== UNRESOLVED) { clearRejectedNoCatch(value); resolvePromise(promise, value[symbolState], value[symbolValue]); } else if (isThenable(value)) { value.then(makeResolver(promise, state), makeResolver(promise, false)); } else { promise[symbolState] = state; var queue = promise[symbolValue]; promise[symbolValue] = value; for (var i = 0; i < queue.length;) { scheduleResolveOrReject(promise, queue[i++], queue[i++], queue[i++], queue[i++]); } if (queue.length == 0 && state == REJECTED) { promise[symbolState] = REJECTED_NO_CATCH; try { throw new Error("Uncaught (in promise): " + value); } catch (e) { var error = e; error.rejection = value; error.promise = promise; error.zone = Zone.current; error.task = Zone.currentTask; _uncaughtPromiseErrors.push(error); scheduleQueueDrain(); } } } } // Resolving an already resolved promise is a noop. return promise; } function clearRejectedNoCatch(promise) { if (promise[symbolState] === REJECTED_NO_CATCH) { promise[symbolState] = REJECTED; for (var i = 0; i < _uncaughtPromiseErrors.length; i++) { if (promise === _uncaughtPromiseErrors[i].promise) { _uncaughtPromiseErrors.splice(i, 1); break; } } } } function scheduleResolveOrReject(promise, zone, chainPromise, onFulfilled, onRejected) { clearRejectedNoCatch(promise); var delegate = promise[symbolState] ? onFulfilled || forwardResolution : onRejected || forwardRejection; zone.scheduleMicroTask(source, function () { try { resolvePromise(chainPromise, true, zone.run(delegate, null, [promise[symbolValue]])); } catch (error) { resolvePromise(chainPromise, false, error); } }); } var ZoneAwarePromise = (function () { function ZoneAwarePromise(executor) { var promise = this; promise[symbolState] = UNRESOLVED; promise[symbolValue] = []; // queue; try { executor && executor(makeResolver(promise, RESOLVED), makeResolver(promise, REJECTED)); } catch (e) { resolvePromise(promise, false, e); } } ZoneAwarePromise.resolve = function (value) { return resolvePromise(new this(null), RESOLVED, value); }; ZoneAwarePromise.reject = function (error) { return resolvePromise(new this(null), REJECTED, error); }; ZoneAwarePromise.race = function (values) { var resolve; var reject; var promise = new this(function (res, rej) { resolve = res; reject = rej; }); function onResolve(value) { promise && (promise = null || resolve(value)); } function onReject(error) { promise && (promise = null || reject(error)); } for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { var value = values_1[_i]; if (!isThenable(value)) { value = this.resolve(value); } value.then(onResolve, onReject); } return promise; }; ZoneAwarePromise.all = function (values) { var resolve; var reject; var promise = new this(function (res, rej) { resolve = res; reject = rej; }); var count = 0; var resolvedValues = []; function onReject(error) { promise && reject(error); promise = null; } for (var _i = 0, values_2 = values; _i < values_2.length; _i++) { var value = values_2[_i]; if (!isThenable(value)) { value = this.resolve(value); } value.then((function (index) { return function (value) { resolvedValues[index] = value; count--; if (promise && !count) { resolve(resolvedValues); } promise == null; }; })(count), onReject); count++; } if (!count) resolve(resolvedValues); return promise; }; ZoneAwarePromise.prototype.then = function (onFulfilled, onRejected) { var chainPromise = new ZoneAwarePromise(null); var zone = Zone.current; if (this[symbolState] == UNRESOLVED) { this[symbolValue].push(zone, chainPromise, onFulfilled, onRejected); } else { scheduleResolveOrReject(this, zone, chainPromise, onFulfilled, onRejected); } return chainPromise; }; ZoneAwarePromise.prototype.catch = function (onRejected) { return this.then(null, onRejected); }; return ZoneAwarePromise; }()); var NativePromise = global[__symbol__('Promise')] = global.Promise; global.Promise = ZoneAwarePromise; if (NativePromise) { var NativePromiseProtototype = NativePromise.prototype; var NativePromiseThen_1 = NativePromiseProtototype[__symbol__('then')] = NativePromiseProtototype.then; NativePromiseProtototype.then = function (onResolve, onReject) { var nativePromise = this; return new ZoneAwarePromise(function (resolve, reject) { NativePromiseThen_1.call(nativePromise, resolve, reject); }).then(onResolve, onReject); }; } return global.Zone = Zone; })(typeof window === 'undefined' ? global : window); /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) /***/ }, /* 2 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var utils_1 = __webpack_require__(3); var WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video'; var NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex'.split(','); var EVENT_TARGET = 'EventTarget'; function eventTargetPatch(_global) { var apis = []; var isWtf = _global['wtf']; if (isWtf) { // Workaround for: https://github.com/google/tracing-framework/issues/555 apis = WTF_ISSUE_555.split(',').map(function (v) { return 'HTML' + v + 'Element'; }).concat(NO_EVENT_TARGET); } else if (_global[EVENT_TARGET]) { apis.push(EVENT_TARGET); } else { // Note: EventTarget is not available in all browsers, // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget apis = NO_EVENT_TARGET; } for (var i = 0; i < apis.length; i++) { var type = _global[apis[i]]; utils_1.patchEventTargetMethods(type && type.prototype); } } exports.eventTargetPatch = eventTargetPatch; /***/ }, /* 3 */ /***/ function(module, exports) { /* WEBPACK VAR INJECTION */(function(global) {/** * Suppress closure compiler errors about unknown 'process' variable * @fileoverview * @suppress {undefinedVars} */ "use strict"; exports.zoneSymbol = Zone['__symbol__']; var _global = typeof window == 'undefined' ? global : window; function bindArguments(args, source) { for (var i = args.length - 1; i >= 0; i--) { if (typeof args[i] === 'function') { args[i] = Zone.current.wrap(args[i], source + '_' + i); } } return args; } exports.bindArguments = bindArguments; ; function patchPrototype(prototype, fnNames) { var source = prototype.constructor['name']; var _loop_1 = function(i) { var name_1 = fnNames[i]; var delegate = prototype[name_1]; if (delegate) { prototype[name_1] = (function (delegate) { return function () { return delegate.apply(this, bindArguments(arguments, source + '.' + name_1)); }; })(delegate); } }; for (var i = 0; i < fnNames.length; i++) { _loop_1(i); } } exports.patchPrototype = patchPrototype; ; exports.isWebWorker = (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope); exports.isNode = (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]'); exports.isBrowser = !exports.isNode && !exports.isWebWorker && !!(typeof window !== 'undefined' && window['HTMLElement']); function patchProperty(obj, prop) { var desc = Object.getOwnPropertyDescriptor(obj, prop) || { enumerable: true, configurable: true }; // A property descriptor cannot have getter/setter and be writable // deleting the writable and value properties avoids this error: // // TypeError: property descriptors must not specify a value or be writable when a // getter or setter has been specified delete desc.writable; delete desc.value; // substr(2) cuz 'onclick' -> 'click', etc var eventName = prop.substr(2); var _prop = '_' + prop; desc.set = function (fn) { if (this[_prop]) { this.removeEventListener(eventName, this[_prop]); } if (typeof fn === 'function') { var wrapFn = function (event) { var result; result = fn.apply(this, arguments); if (result != undefined && !result) event.preventDefault(); }; this[_prop] = wrapFn; this.addEventListener(eventName, wrapFn, false); } else { this[_prop] = null; } }; desc.get = function () { return this[_prop]; }; Object.defineProperty(obj, prop, desc); } exports.patchProperty = patchProperty; ; function patchOnProperties(obj, properties) { var onProperties = []; for (var prop in obj) { if (prop.substr(0, 2) == 'on') { onProperties.push(prop); } } for (var j = 0; j < onProperties.length; j++) { patchProperty(obj, onProperties[j]); } if (properties) { for (var i = 0; i < properties.length; i++) { patchProperty(obj, 'on' + properties[i]); } } } exports.patchOnProperties = patchOnProperties; ; var EVENT_TASKS = exports.zoneSymbol('eventTasks'); var ADD_EVENT_LISTENER = 'addEventListener'; var REMOVE_EVENT_LISTENER = 'removeEventListener'; var SYMBOL_ADD_EVENT_LISTENER = exports.zoneSymbol(ADD_EVENT_LISTENER); var SYMBOL_REMOVE_EVENT_LISTENER = exports.zoneSymbol(REMOVE_EVENT_LISTENER); function findExistingRegisteredTask(target, handler, name, capture, remove) { var eventTasks = target[EVENT_TASKS]; if (eventTasks) { for (var i = 0; i < eventTasks.length; i++) { var eventTask = eventTasks[i]; var data = eventTask.data; if (data.handler === handler && data.useCapturing === capture && data.eventName === name) { if (remove) { eventTasks.splice(i, 1); } return eventTask; } } } return null; } function attachRegisteredEvent(target, eventTask) { var eventTasks = target[EVENT_TASKS]; if (!eventTasks) { eventTasks = target[EVENT_TASKS] = []; } eventTasks.push(eventTask); } function scheduleEventListener(eventTask) { var meta = eventTask.data; attachRegisteredEvent(meta.target, eventTask); return meta.target[SYMBOL_ADD_EVENT_LISTENER](meta.eventName, eventTask.invoke, meta.useCapturing); } function cancelEventListener(eventTask) { var meta = eventTask.data; findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName, meta.useCapturing, true); meta.target[SYMBOL_REMOVE_EVENT_LISTENER](meta.eventName, eventTask.invoke, meta.useCapturing); } function zoneAwareAddEventListener(self, args) { var eventName = args[0]; var handler = args[1]; var useCapturing = args[2] || false; // - Inside a Web Worker, `this` is undefined, the context is `global` // - When `addEventListener` is called on the global context in strict mode, `this` is undefined // see https://github.com/angular/zone.js/issues/190 var target = self || _global; var delegate = null; if (typeof handler == 'function') { delegate = handler; } else if (handler && handler.handleEvent) { delegate = function (event) { return handler.handleEvent(event); }; } var validZoneHandler = false; try { // In cross site contexts (such as WebDriver frameworks like Selenium), // accessing the handler object here will cause an exception to be thrown which // will fail tests prematurely. validZoneHandler = handler && handler.toString() === "[object FunctionWrapper]"; } catch (e) { // Returning nothing here is fine, because objects in a cross-site context are unusable return; } // Ignore special listeners of IE11 & Edge dev tools, see https://github.com/angular/zone.js/issues/150 if (!delegate || validZoneHandler) { return target[SYMBOL_ADD_EVENT_LISTENER](eventName, handler, useCapturing); } var eventTask = findExistingRegisteredTask(target, handler, eventName, useCapturing, false); if (eventTask) { // we already registered, so this will have noop. return target[SYMBOL_ADD_EVENT_LISTENER](eventName, eventTask.invoke, useCapturing); } var zone = Zone.current; var source = target.constructor['name'] + '.addEventListener:' + eventName; var data = { target: target, eventName: eventName, name: eventName, useCapturing: useCapturing, handler: handler }; zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener); } function zoneAwareRemoveEventListener(self, args) { var eventName = args[0]; var handler = args[1]; var useCapturing = args[2] || false; // - Inside a Web Worker, `this` is undefined, the context is `global` // - When `addEventListener` is called on the global context in strict mode, `this` is undefined // see https://github.com/angular/zone.js/issues/190 var target = self || _global; var eventTask = findExistingRegisteredTask(target, handler, eventName, useCapturing, true); if (eventTask) { eventTask.zone.cancelTask(eventTask); } else { target[SYMBOL_REMOVE_EVENT_LISTENER](eventName, handler, useCapturing); } } function patchEventTargetMethods(obj) { if (obj && obj.addEventListener) { patchMethod(obj, ADD_EVENT_LISTENER, function () { return zoneAwareAddEventListener; }); patchMethod(obj, REMOVE_EVENT_LISTENER, function () { return zoneAwareRemoveEventListener; }); return true; } else { return false; } } exports.patchEventTargetMethods = patchEventTargetMethods; ; var originalInstanceKey = exports.zoneSymbol('originalInstance'); // wrap some native API on `window` function patchClass(className) { var OriginalClass = _global[className]; if (!OriginalClass) return; _global[className] = function () { var a = bindArguments(arguments, className); switch (a.length) { case 0: this[originalInstanceKey] = new OriginalClass(); break; case 1: this[originalInstanceKey] = new OriginalClass(a[0]); break; case 2: this[originalInstanceKey] = new OriginalClass(a[0], a[1]); break; case 3: this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]); break; case 4: this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]); break; default: throw new Error('Arg list too long.'); } }; var instance = new OriginalClass(function () { }); var prop; for (prop in instance) { (function (prop) { if (typeof instance[prop] === 'function') { _global[className].prototype[prop] = function () { return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments); }; } else { Object.defineProperty(_global[className].prototype, prop, { set: function (fn) { if (typeof fn === 'function') { this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop); } else { this[originalInstanceKey][prop] = fn; } }, get: function () { return this[originalInstanceKey][prop]; } }); } }(prop)); } for (prop in OriginalClass) { if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) { _global[className][prop] = OriginalClass[prop]; } } } exports.patchClass = patchClass; ; function createNamedFn(name, delegate) { try { return (Function('f', "return function " + name + "(){return f(this, arguments)}"))(delegate); } catch (e) { // if we fail, we must be CSP, just return delegate. return function () { return delegate(this, arguments); }; } } exports.createNamedFn = createNamedFn; function patchMethod(target, name, patchFn) { var proto = target; while (proto && !proto.hasOwnProperty(name)) { proto = Object.getPrototypeOf(proto); } if (!proto && target[name]) { // somehow we did not find it, but we can see it. This happens on IE for Window properties. proto = target; } var delegateName = exports.zoneSymbol(name); var delegate; if (proto && !(delegate = proto[delegateName])) { delegate = proto[delegateName] = proto[name]; proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name)); } return delegate; } exports.patchMethod = patchMethod; /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) /***/ }, /* 4 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var utils_1 = __webpack_require__(3); /* * This is necessary for Chrome and Chrome mobile, to enable * things like redefining `createdCallback` on an element. */ var _defineProperty = Object.defineProperty; var _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; var _create = Object.create; var unconfigurablesKey = utils_1.zoneSymbol('unconfigurables'); function propertyPatch() { Object.defineProperty = function (obj, prop, desc) { if (isUnconfigurable(obj, prop)) { throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj); } if (prop !== 'prototype') { desc = rewriteDescriptor(obj, prop, desc); } return _defineProperty(obj, prop, desc); }; Object.defineProperties = function (obj, props) { Object.keys(props).forEach(function (prop) { Object.defineProperty(obj, prop, props[prop]); }); return obj; }; Object.create = function (obj, proto) { if (typeof proto === 'object') { Object.keys(proto).forEach(function (prop) { proto[prop] = rewriteDescriptor(obj, prop, proto[prop]); }); } return _create(obj, proto); }; Object.getOwnPropertyDescriptor = function (obj, prop) { var desc = _getOwnPropertyDescriptor(obj, prop); if (isUnconfigurable(obj, prop)) { desc.configurable = false; } return desc; }; } exports.propertyPatch = propertyPatch; ; function _redefineProperty(obj, prop, desc) { desc = rewriteDescriptor(obj, prop, desc); return _defineProperty(obj, prop, desc); } exports._redefineProperty = _redefineProperty; ; function isUnconfigurable(obj, prop) { return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop]; } function rewriteDescriptor(obj, prop, desc) { desc.configurable = true; if (!desc.configurable) { if (!obj[unconfigurablesKey]) { _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} }); } obj[unconfigurablesKey][prop] = true; } return desc; } /***/ }, /* 5 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var define_property_1 = __webpack_require__(4); var utils_1 = __webpack_require__(3); function registerElementPatch(_global) { if (!utils_1.isBrowser || !('registerElement' in _global.document)) { return; } var _registerElement = document.registerElement; var callbacks = [ 'createdCallback', 'attachedCallback', 'detachedCallback', 'attributeChangedCallback' ]; document.registerElement = function (name, opts) { if (opts && opts.prototype) { callbacks.forEach(function (callback) { var source = 'Document.registerElement::' + callback; if (opts.prototype.hasOwnProperty(callback)) { var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback); if (descriptor && descriptor.value) { descriptor.value = Zone.current.wrap(descriptor.value, source); define_property_1._redefineProperty(opts.prototype, callback, descriptor); } else { opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source); } } else if (opts.prototype[callback]) { opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source); } }); } return _registerElement.apply(document, [name, opts]); }; } exports.registerElementPatch = registerElementPatch; /***/ }, /* 6 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var webSocketPatch = __webpack_require__(7); var utils_1 = __webpack_require__(3); var eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'.split(' '); function propertyDescriptorPatch(_global) { if (utils_1.isNode) { return; } var supportsWebSocket = typeof WebSocket !== 'undefined'; if (canPatchViaPropertyDescriptor()) { // for browsers that we can patch the descriptor: Chrome & Firefox if (utils_1.isBrowser) { utils_1.patchOnProperties(HTMLElement.prototype, eventNames); } utils_1.patchOnProperties(XMLHttpRequest.prototype, null); if (typeof IDBIndex !== 'undefined') { utils_1.patchOnProperties(IDBIndex.prototype, null); utils_1.patchOnProperties(IDBRequest.prototype, null); utils_1.patchOnProperties(IDBOpenDBRequest.prototype, null); utils_1.patchOnProperties(IDBDatabase.prototype, null); utils_1.patchOnProperties(IDBTransaction.prototype, null); utils_1.patchOnProperties(IDBCursor.prototype, null); } if (supportsWebSocket) { utils_1.patchOnProperties(WebSocket.prototype, null); } } else { // Safari, Android browsers (Jelly Bean) patchViaCapturingAllTheEvents(); utils_1.patchClass('XMLHttpRequest'); if (supportsWebSocket) { webSocketPatch.apply(_global); } } } exports.propertyDescriptorPatch = propertyDescriptorPatch; function canPatchViaPropertyDescriptor() { if (utils_1.isBrowser && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') && typeof Element !== 'undefined') { // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364 // IDL interface attributes are not configurable var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick'); if (desc && !desc.configurable) return false; } Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', { get: function () { return true; } }); var req = new XMLHttpRequest(); var result = !!req.onreadystatechange; Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {}); return result; } ; var unboundKey = utils_1.zoneSymbol('unbound'); // Whenever any eventListener fires, we check the eventListener target and all parents // for `onwhatever` properties and replace them with zone-bound functions // - Chrome (for now) function patchViaCapturingAllTheEvents() { var _loop_1 = function(i) { var property = eventNames[i]; var onproperty = 'on' + property; document.addEventListener(property, function (event) { var elt = event.target, bound, source; if (elt) { source = elt.constructor['name'] + '.' + onproperty; } else { source = 'unknown.' + onproperty; } while (elt) { if (elt[onproperty] && !elt[onproperty][unboundKey]) { bound = Zone.current.wrap(elt[onproperty], source); bound[unboundKey] = elt[onproperty]; elt[onproperty] = bound; } elt = elt.parentElement; } }, true); }; for (var i = 0; i < eventNames.length; i++) { _loop_1(i); } ; } ; /***/ }, /* 7 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var utils_1 = __webpack_require__(3); // we have to patch the instance since the proto is non-configurable function apply(_global) { var WS = _global.WebSocket; // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener // On older Chrome, no need since EventTarget was already patched if (!_global.EventTarget) { utils_1.patchEventTargetMethods(WS.prototype); } _global.WebSocket = function (a, b) { var socket = arguments.length > 1 ? new WS(a, b) : new WS(a); var proxySocket; // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage'); if (onmessageDesc && onmessageDesc.configurable === false) { proxySocket = Object.create(socket); ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function (propName) { proxySocket[propName] = function () { return socket[propName].apply(socket, arguments); }; }); } else { // we can patch the real socket proxySocket = socket; } utils_1.patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']); return proxySocket; }; for (var prop in WS) { _global.WebSocket[prop] = WS[prop]; } } exports.apply = apply; /***/ }, /* 8 */ /***/ function(module, exports, __webpack_require__) { "use strict"; var utils_1 = __webpack_require__(3); function patchTimer(window, setName, cancelName, nameSuffix) { var setNative = null; var clearNative = null; setName += nameSuffix; cancelName += nameSuffix; function scheduleTask(task) { var data = task.data; data.args[0] = task.invoke; data.handleId = setNative.apply(window, data.args); return task; } function clearTask(task) { return clearNative(task.data.handleId); } setNative = utils_1.patchMethod(window, setName, function (delegate) { return function (self, args) { if (typeof args[0] === 'function') { var zone = Zone.current; var options = { handleId: null, isPeriodic: nameSuffix === 'Interval', delay: (nameSuffix === 'Timeout' || nameSuffix === 'Interval') ? args[1] || 0 : null, args: args }; return zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask); } else { // cause an error by calling it directly. return delegate.apply(window, args); } }; }); clearNative = utils_1.patchMethod(window, cancelName, function (delegate) { return function (self, args) { var task = args[0]; if (task && typeof task.type === 'string') { if (task.cancelFn && task.data.isPeriodic || task.runCount === 0) { // Do not cancel already canceled functions task.zone.cancelTask(task); } } else { // cause an error by calling it directly. delegate.apply(window, args); } }; }); } exports.patchTimer = patchTimer; /***/ } /******/ ]); /******/ (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] = { /******/ exports: {}, /******/ id: moduleId, /******/ loaded: false /******/ }; /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ // Flag the module as loaded /******/ module.loaded = 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; /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ // Load entry module and return exports /******/ return __webpack_require__(0); /******/ }) /************************************************************************/ /******/ ([ /* 0 */ /***/ function(module, exports) { 'use strict'; (function () { var NEWLINE = '\n'; var SEP = ' ------------- '; var IGNORE_FRAMES = []; var creationTrace = '__creationTrace__'; var LongStackTrace = (function () { function LongStackTrace() { this.error = getStacktrace(); this.timestamp = new Date(); } return LongStackTrace; }()); function getStacktraceWithUncaughtError() { return new Error('STACKTRACE TRACKING'); } function getStacktraceWithCaughtError() { try { throw getStacktraceWithUncaughtError(); } catch (e) { return e; } } // Some implementations of exception handling don't create a stack trace if the exception // isn't thrown, however it's faster not to actually throw the exception. var error = getStacktraceWithUncaughtError(); var coughtError = getStacktraceWithCaughtError(); var getStacktrace = error.stack ? getStacktraceWithUncaughtError : (coughtError.stack ? getStacktraceWithCaughtError : getStacktraceWithUncaughtError); function getFrames(error) { return error.stack ? error.stack.split(NEWLINE) : []; } function addErrorStack(lines, error) { var trace = getFrames(error); for (var i = 0; i < trace.length; i++) { var frame = trace[i]; // Filter out the Frames which are part of stack capturing. if (!(i < IGNORE_FRAMES.length && IGNORE_FRAMES[i] === frame)) { lines.push(trace[i]); } } } function renderLongStackTrace(frames, stack) { var longTrace = [stack]; if (frames) { var timestamp = new Date().getTime(); for (var i = 0; i < frames.length; i++) { var traceFrames = frames[i]; var lastTime = traceFrames.timestamp; longTrace.push(SEP + " Elapsed: " + (timestamp - lastTime.getTime()) + " ms; At: " + lastTime + " " + SEP); addErrorStack(longTrace, traceFrames.error); timestamp = lastTime.getTime(); } } return longTrace.join(NEWLINE); } Zone['longStackTraceZoneSpec'] = { name: 'long-stack-trace', longStackTraceLimit: 10, onScheduleTask: function (parentZoneDelegate, currentZone, targetZone, task) { var currentTask = Zone.currentTask; var trace = currentTask && currentTask.data && currentTask.data[creationTrace] || []; trace = [new LongStackTrace()].concat(trace); if (trace.length > this.longStackTraceLimit) { trace.length = this.longStackTraceLimit; } if (!task.data) task.data = {}; task.data[creationTrace] = trace; return parentZoneDelegate.scheduleTask(targetZone, task); }, onHandleError: function (parentZoneDelegate, currentZone, targetZone, error) { var parentTask = Zone.currentTask; if (error instanceof Error && parentTask) { var descriptor = Object.getOwnPropertyDescriptor(error, 'stack'); if (descriptor) { var delegateGet_1 = descriptor.get; var value_1 = descriptor.value; descriptor = { get: function () { return renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], delegateGet_1 ? delegateGet_1.apply(this) : value_1); } }; Object.defineProperty(error, 'stack', descriptor); } else { error.stack = renderLongStackTrace(parentTask.data && parentTask.data[creationTrace], error.stack); } } return parentZoneDelegate.handleError(targetZone, error); } }; function captureStackTraces(stackTraces, count) { if (count > 0) { stackTraces.push(getFrames((new LongStackTrace()).error)); captureStackTraces(stackTraces, count - 1); } } function computeIgnoreFrames() { var frames = []; captureStackTraces(frames, 2); var frames1 = frames[0]; var frames2 = frames[1]; for (var i = 0; i < frames1.length; i++) { var frame1 = frames1[i]; var frame2 = frames2[i]; if (frame1 === frame2) { IGNORE_FRAMES.push(frame1); } else { break; } } } computeIgnoreFrames(); })(); /***/ } /******/ ]); /*! ***************************************************************************** Copyright (C) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT. See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ var Reflect; (function (Reflect) { "use strict"; // Load global or shim versions of Map, Set, and WeakMap var functionPrototype = Object.getPrototypeOf(Function); var _Map = typeof Map === "function" ? Map : CreateMapPolyfill(); var _Set = typeof Set === "function" ? Set : CreateSetPolyfill(); var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); // [[Metadata]] internal slot var __Metadata__ = new _WeakMap(); /** * Applies a set of decorators to a property of a target object. * @param decorators An array of decorators. * @param target The target object. * @param targetKey (Optional) The property key to decorate. * @param targetDescriptor (Optional) The property descriptor for the target key * @remarks Decorators are applied in reverse order. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * C = Reflect.decorate(decoratorsArray, C); * * // property (on constructor) * Reflect.decorate(decoratorsArray, C, "staticProperty"); * * // property (on prototype) * Reflect.decorate(decoratorsArray, C.prototype, "property"); * * // method (on constructor) * Object.defineProperty(C, "staticMethod", * Reflect.decorate(decoratorsArray, C, "staticMethod", * Object.getOwnPropertyDescriptor(C, "staticMethod"))); * * // method (on prototype) * Object.defineProperty(C.prototype, "method", * Reflect.decorate(decoratorsArray, C.prototype, "method", * Object.getOwnPropertyDescriptor(C.prototype, "method"))); * */ function decorate(decorators, target, targetKey, targetDescriptor) { if (!IsUndefined(targetDescriptor)) { if (!IsArray(decorators)) { throw new TypeError(); } else if (!IsObject(target)) { throw new TypeError(); } else if (IsUndefined(targetKey)) { throw new TypeError(); } else if (!IsObject(targetDescriptor)) { throw new TypeError(); } targetKey = ToPropertyKey(targetKey); return DecoratePropertyWithDescriptor(decorators, target, targetKey, targetDescriptor); } else if (!IsUndefined(targetKey)) { if (!IsArray(decorators)) { throw new TypeError(); } else if (!IsObject(target)) { throw new TypeError(); } targetKey = ToPropertyKey(targetKey); return DecoratePropertyWithoutDescriptor(decorators, target, targetKey); } else { if (!IsArray(decorators)) { throw new TypeError(); } else if (!IsConstructor(target)) { throw new TypeError(); } return DecorateConstructor(decorators, target); } } Reflect.decorate = decorate; /** * A default metadata decorator factory that can be used on a class, class member, or parameter. * @param metadataKey The key for the metadata entry. * @param metadataValue The value for the metadata entry. * @returns A decorator function. * @remarks * If `metadataKey` is already defined for the target and target key, the * metadataValue for that key will be overwritten. * @example * * // constructor * @Reflect.metadata(key, value) * class C { * } * * // property (on constructor, TypeScript only) * class C { * @Reflect.metadata(key, value) * static staticProperty; * } * * // property (on prototype, TypeScript only) * class C { * @Reflect.metadata(key, value) * property; * } * * // method (on constructor) * class C { * @Reflect.metadata(key, value) * static staticMethod() { } * } * * // method (on prototype) * class C { * @Reflect.metadata(key, value) * method() { } * } * */ function metadata(metadataKey, metadataValue) { function decorator(target, targetKey) { if (!IsUndefined(targetKey)) { if (!IsObject(target)) { throw new TypeError(); } targetKey = ToPropertyKey(targetKey); OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); } else { if (!IsConstructor(target)) { throw new TypeError(); } OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, /*targetKey*/ undefined); } } return decorator; } Reflect.metadata = metadata; /** * Define a unique metadata entry on the target. * @param metadataKey A key used to store and retrieve metadata. * @param metadataValue A value that contains attached metadata. * @param target The target object on which to define metadata. * @param targetKey (Optional) The property key for the target. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * Reflect.defineMetadata("custom:annotation", options, C); * * // property (on constructor) * Reflect.defineMetadata("custom:annotation", options, C, "staticProperty"); * * // property (on prototype) * Reflect.defineMetadata("custom:annotation", options, C.prototype, "property"); * * // method (on constructor) * Reflect.defineMetadata("custom:annotation", options, C, "staticMethod"); * * // method (on prototype) * Reflect.defineMetadata("custom:annotation", options, C.prototype, "method"); * * // decorator factory as metadata-producing annotation. * function MyAnnotation(options): Decorator { * return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key); * } * */ function defineMetadata(metadataKey, metadataValue, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); } Reflect.defineMetadata = defineMetadata; /** * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined. * @param metadataKey A key used to store and retrieve metadata. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.hasMetadata("custom:annotation", C); * * // property (on constructor) * result = Reflect.hasMetadata("custom:annotation", C, "staticProperty"); * * // property (on prototype) * result = Reflect.hasMetadata("custom:annotation", C.prototype, "property"); * * // method (on constructor) * result = Reflect.hasMetadata("custom:annotation", C, "staticMethod"); * * // method (on prototype) * result = Reflect.hasMetadata("custom:annotation", C.prototype, "method"); * */ function hasMetadata(metadataKey, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryHasMetadata(metadataKey, target, targetKey); } Reflect.hasMetadata = hasMetadata; /** * Gets a value indicating whether the target object has the provided metadata key defined. * @param metadataKey A key used to store and retrieve metadata. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns `true` if the metadata key was defined on the target object; otherwise, `false`. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.hasOwnMetadata("custom:annotation", C); * * // property (on constructor) * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticProperty"); * * // property (on prototype) * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "property"); * * // method (on constructor) * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticMethod"); * * // method (on prototype) * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "method"); * */ function hasOwnMetadata(metadataKey, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryHasOwnMetadata(metadataKey, target, targetKey); } Reflect.hasOwnMetadata = hasOwnMetadata; /** * Gets the metadata value for the provided metadata key on the target object or its prototype chain. * @param metadataKey A key used to store and retrieve metadata. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns The metadata value for the metadata key if found; otherwise, `undefined`. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.getMetadata("custom:annotation", C); * * // property (on constructor) * result = Reflect.getMetadata("custom:annotation", C, "staticProperty"); * * // property (on prototype) * result = Reflect.getMetadata("custom:annotation", C.prototype, "property"); * * // method (on constructor) * result = Reflect.getMetadata("custom:annotation", C, "staticMethod"); * * // method (on prototype) * result = Reflect.getMetadata("custom:annotation", C.prototype, "method"); * */ function getMetadata(metadataKey, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryGetMetadata(metadataKey, target, targetKey); } Reflect.getMetadata = getMetadata; /** * Gets the metadata value for the provided metadata key on the target object. * @param metadataKey A key used to store and retrieve metadata. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns The metadata value for the metadata key if found; otherwise, `undefined`. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.getOwnMetadata("custom:annotation", C); * * // property (on constructor) * result = Reflect.getOwnMetadata("custom:annotation", C, "staticProperty"); * * // property (on prototype) * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "property"); * * // method (on constructor) * result = Reflect.getOwnMetadata("custom:annotation", C, "staticMethod"); * * // method (on prototype) * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "method"); * */ function getOwnMetadata(metadataKey, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryGetOwnMetadata(metadataKey, target, targetKey); } Reflect.getOwnMetadata = getOwnMetadata; /** * Gets the metadata keys defined on the target object or its prototype chain. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns An array of unique metadata keys. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.getMetadataKeys(C); * * // property (on constructor) * result = Reflect.getMetadataKeys(C, "staticProperty"); * * // property (on prototype) * result = Reflect.getMetadataKeys(C.prototype, "property"); * * // method (on constructor) * result = Reflect.getMetadataKeys(C, "staticMethod"); * * // method (on prototype) * result = Reflect.getMetadataKeys(C.prototype, "method"); * */ function getMetadataKeys(target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryMetadataKeys(target, targetKey); } Reflect.getMetadataKeys = getMetadataKeys; /** * Gets the unique metadata keys defined on the target object. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns An array of unique metadata keys. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.getOwnMetadataKeys(C); * * // property (on constructor) * result = Reflect.getOwnMetadataKeys(C, "staticProperty"); * * // property (on prototype) * result = Reflect.getOwnMetadataKeys(C.prototype, "property"); * * // method (on constructor) * result = Reflect.getOwnMetadataKeys(C, "staticMethod"); * * // method (on prototype) * result = Reflect.getOwnMetadataKeys(C.prototype, "method"); * */ function getOwnMetadataKeys(target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } return OrdinaryOwnMetadataKeys(target, targetKey); } Reflect.getOwnMetadataKeys = getOwnMetadataKeys; /** * Deletes the metadata entry from the target object with the provided key. * @param metadataKey A key used to store and retrieve metadata. * @param target The target object on which the metadata is defined. * @param targetKey (Optional) The property key for the target. * @returns `true` if the metadata entry was found and deleted; otherwise, false. * @example * * class C { * // property declarations are not part of ES6, though they are valid in TypeScript: * // static staticProperty; * // property; * * constructor(p) { } * static staticMethod(p) { } * method(p) { } * } * * // constructor * result = Reflect.deleteMetadata("custom:annotation", C); * * // property (on constructor) * result = Reflect.deleteMetadata("custom:annotation", C, "staticProperty"); * * // property (on prototype) * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "property"); * * // method (on constructor) * result = Reflect.deleteMetadata("custom:annotation", C, "staticMethod"); * * // method (on prototype) * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "method"); * */ function deleteMetadata(metadataKey, target, targetKey) { if (!IsObject(target)) { throw new TypeError(); } else if (!IsUndefined(targetKey)) { targetKey = ToPropertyKey(targetKey); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#deletemetadata-metadatakey-p- var metadataMap = GetOrCreateMetadataMap(target, targetKey, /*create*/ false); if (IsUndefined(metadataMap)) { return false; } if (!metadataMap.delete(metadataKey)) { return false; } if (metadataMap.size > 0) { return true; } var targetMetadata = __Metadata__.get(target); targetMetadata.delete(targetKey); if (targetMetadata.size > 0) { return true; } __Metadata__.delete(target); return true; } Reflect.deleteMetadata = deleteMetadata; function DecorateConstructor(decorators, target) { for (var i = decorators.length - 1; i >= 0; --i) { var decorator = decorators[i]; var decorated = decorator(target); if (!IsUndefined(decorated)) { if (!IsConstructor(decorated)) { throw new TypeError(); } target = decorated; } } return target; } function DecoratePropertyWithDescriptor(decorators, target, propertyKey, descriptor) { for (var i = decorators.length - 1; i >= 0; --i) { var decorator = decorators[i]; var decorated = decorator(target, propertyKey, descriptor); if (!IsUndefined(decorated)) { if (!IsObject(decorated)) { throw new TypeError(); } descriptor = decorated; } } return descriptor; } function DecoratePropertyWithoutDescriptor(decorators, target, propertyKey) { for (var i = decorators.length - 1; i >= 0; --i) { var decorator = decorators[i]; decorator(target, propertyKey); } } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#getorcreatemetadatamap--o-p-create- function GetOrCreateMetadataMap(target, targetKey, create) { var targetMetadata = __Metadata__.get(target); if (!targetMetadata) { if (!create) { return undefined; } targetMetadata = new _Map(); __Metadata__.set(target, targetMetadata); } var keyMetadata = targetMetadata.get(targetKey); if (!keyMetadata) { if (!create) { return undefined; } keyMetadata = new _Map(); targetMetadata.set(targetKey, keyMetadata); } return keyMetadata; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasmetadata--metadatakey-o-p- function OrdinaryHasMetadata(MetadataKey, O, P) { var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); if (hasOwn) { return true; } var parent = GetPrototypeOf(O); if (parent !== null) { return OrdinaryHasMetadata(MetadataKey, parent, P); } return false; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasownmetadata--metadatakey-o-p- function OrdinaryHasOwnMetadata(MetadataKey, O, P) { var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ false); if (metadataMap === undefined) { return false; } return Boolean(metadataMap.has(MetadataKey)); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetmetadata--metadatakey-o-p- function OrdinaryGetMetadata(MetadataKey, O, P) { var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); if (hasOwn) { return OrdinaryGetOwnMetadata(MetadataKey, O, P); } var parent = GetPrototypeOf(O); if (parent !== null) { return OrdinaryGetMetadata(MetadataKey, parent, P); } return undefined; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetownmetadata--metadatakey-o-p- function OrdinaryGetOwnMetadata(MetadataKey, O, P) { var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ false); if (metadataMap === undefined) { return undefined; } return metadataMap.get(MetadataKey); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarydefineownmetadata--metadatakey-metadatavalue-o-p- function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { var metadataMap = GetOrCreateMetadataMap(O, P, /*create*/ true); metadataMap.set(MetadataKey, MetadataValue); } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarymetadatakeys--o-p- function OrdinaryMetadataKeys(O, P) { var ownKeys = OrdinaryOwnMetadataKeys(O, P); var parent = GetPrototypeOf(O); if (parent === null) { return ownKeys; } var parentKeys = OrdinaryMetadataKeys(parent, P); if (parentKeys.length <= 0) { return ownKeys; } if (ownKeys.length <= 0) { return parentKeys; } var set = new _Set(); var keys = []; for (var _i = 0; _i < ownKeys.length; _i++) { var key = ownKeys[_i]; var hasKey = set.has(key); if (!hasKey) { set.add(key); keys.push(key); } } for (var _a = 0; _a < parentKeys.length; _a++) { var key = parentKeys[_a]; var hasKey = set.has(key); if (!hasKey) { set.add(key); keys.push(key); } } return keys; } // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryownmetadatakeys--o-p- function OrdinaryOwnMetadataKeys(target, targetKey) { var metadataMap = GetOrCreateMetadataMap(target, targetKey, /*create*/ false); var keys = []; if (metadataMap) { metadataMap.forEach(function (_, key) { return keys.push(key); }); } return keys; } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-undefined-type function IsUndefined(x) { return x === undefined; } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray function IsArray(x) { return Array.isArray(x); } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-type function IsObject(x) { return typeof x === "object" ? x !== null : typeof x === "function"; } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor function IsConstructor(x) { return typeof x === "function"; } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-symbol-type function IsSymbol(x) { return typeof x === "symbol"; } // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey function ToPropertyKey(value) { if (IsSymbol(value)) { return value; } return String(value); } function GetPrototypeOf(O) { var proto = Object.getPrototypeOf(O); if (typeof O !== "function" || O === functionPrototype) { return proto; } // TypeScript doesn't set __proto__ in ES5, as it's non-standard. // Try to determine the superclass constructor. Compatible implementations // must either set __proto__ on a subclass constructor to the superclass constructor, // or ensure each class has a valid `constructor` property on its prototype that // points back to the constructor. // If this is not the same as Function.[[Prototype]], then this is definately inherited. // This is the case when in ES6 or when using __proto__ in a compatible browser. if (proto !== functionPrototype) { return proto; } // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage. var prototype = O.prototype; var prototypeProto = Object.getPrototypeOf(prototype); if (prototypeProto == null || prototypeProto === Object.prototype) { return proto; } // if the constructor was not a function, then we cannot determine the heritage. var constructor = prototypeProto.constructor; if (typeof constructor !== "function") { return proto; } // if we have some kind of self-reference, then we cannot determine the heritage. if (constructor === O) { return proto; } // we have a pretty good guess at the heritage. return constructor; } // naive Map shim function CreateMapPolyfill() { var cacheSentinel = {}; function Map() { this._keys = []; this._values = []; this._cache = cacheSentinel; } Map.prototype = { get size() { return this._keys.length; }, has: function (key) { if (key === this._cache) { return true; } if (this._find(key) >= 0) { this._cache = key; return true; } return false; }, get: function (key) { var index = this._find(key); if (index >= 0) { this._cache = key; return this._values[index]; } return undefined; }, set: function (key, value) { this.delete(key); this._keys.push(key); this._values.push(value); this._cache = key; return this; }, delete: function (key) { var index = this._find(key); if (index >= 0) { this._keys.splice(index, 1); this._values.splice(index, 1); this._cache = cacheSentinel; return true; } return false; }, clear: function () { this._keys.length = 0; this._values.length = 0; this._cache = cacheSentinel; }, forEach: function (callback, thisArg) { var size = this.size; for (var i = 0; i < size; ++i) { var key = this._keys[i]; var value = this._values[i]; this._cache = key; callback.call(this, value, key, this); } }, _find: function (key) { var keys = this._keys; var size = keys.length; for (var i = 0; i < size; ++i) { if (keys[i] === key) { return i; } } return -1; } }; return Map; } // naive Set shim function CreateSetPolyfill() { var cacheSentinel = {}; function Set() { this._map = new _Map(); } Set.prototype = { get size() { return this._map.length; }, has: function (value) { return this._map.has(value); }, add: function (value) { this._map.set(value, value); return this; }, delete: function (value) { return this._map.delete(value); }, clear: function () { this._map.clear(); }, forEach: function (callback, thisArg) { this._map.forEach(callback, thisArg); } }; return Set; } // naive WeakMap shim function CreateWeakMapPolyfill() { var UUID_SIZE = 16; var isNode = typeof global !== "undefined" && Object.prototype.toString.call(global.process) === '[object process]'; var nodeCrypto = isNode && require("crypto"); var hasOwn = Object.prototype.hasOwnProperty; var keys = {}; var rootKey = CreateUniqueKey(); function WeakMap() { this._key = CreateUniqueKey(); } WeakMap.prototype = { has: function (target) { var table = GetOrCreateWeakMapTable(target, /*create*/ false); if (table) { return this._key in table; } return false; }, get: function (target) { var table = GetOrCreateWeakMapTable(target, /*create*/ false); if (table) { return table[this._key]; } return undefined; }, set: function (target, value) { var table = GetOrCreateWeakMapTable(target, /*create*/ true); table[this._key] = value; return this; }, delete: function (target) { var table = GetOrCreateWeakMapTable(target, /*create*/ false); if (table && this._key in table) { return delete table[this._key]; } return false; }, clear: function () { // NOTE: not a real clear, just makes the previous data unreachable this._key = CreateUniqueKey(); } }; function FillRandomBytes(buffer, size) { for (var i = 0; i < size; ++i) { buffer[i] = Math.random() * 255 | 0; } } function GenRandomBytes(size) { if (nodeCrypto) { var data = nodeCrypto.randomBytes(size); return data; } else if (typeof Uint8Array === "function") { var data = new Uint8Array(size); if (typeof crypto !== "undefined") { crypto.getRandomValues(data); } else if (typeof msCrypto !== "undefined") { msCrypto.getRandomValues(data); } else { FillRandomBytes(data, size); } return data; } else { var data = new Array(size); FillRandomBytes(data, size); return data; } } function CreateUUID() { var data = GenRandomBytes(UUID_SIZE); // mark as random - RFC 4122 § 4.4 data[6] = data[6] & 0x4f | 0x40; data[8] = data[8] & 0xbf | 0x80; var result = ""; for (var offset = 0; offset < UUID_SIZE; ++offset) { var byte = data[offset]; if (offset === 4 || offset === 6 || offset === 8) { result += "-"; } if (byte < 16) { result += "0"; } result += byte.toString(16).toLowerCase(); } return result; } function CreateUniqueKey() { var key; do { key = "@@WeakMap@@" + CreateUUID(); } while (hasOwn.call(keys, key)); keys[key] = true; return key; } function GetOrCreateWeakMapTable(target, create) { if (!hasOwn.call(target, rootKey)) { if (!create) { return undefined; } Object.defineProperty(target, rootKey, { value: Object.create(null) }); } return target[rootKey]; } return WeakMap; } // hook global Reflect (function (__global) { if (typeof __global.Reflect !== "undefined") { if (__global.Reflect !== Reflect) { for (var p in Reflect) { __global.Reflect[p] = Reflect[p]; } } } else { __global.Reflect = Reflect; } })(typeof window !== "undefined" ? window : typeof WorkerGlobalScope !== "undefined" ? self : typeof global !== "undefined" ? global : Function("return this;")()); })(Reflect || (Reflect = {})); (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 2 ? $$[2] : undefined , count = Math.min((end === undefined ? len : toIndex(end, len)) - from, len - to) , inc = 1; if(from < to && to < from + count){ inc = -1; from += count - 1; to += count - 1; } while(count-- > 0){ if(from in O)O[to] = O[from]; else delete O[to]; to += inc; from += inc; } return O; }; },{"77":77,"80":80,"81":81}],7:[function(_dereq_,module,exports){ // 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length) 'use strict'; var toObject = _dereq_(81) , toIndex = _dereq_(77) , toLength = _dereq_(80); module.exports = [].fill || function fill(value /*, start = 0, end = @length */){ var O = toObject(this) , length = toLength(O.length) , $$ = arguments , $$len = $$.length , index = toIndex($$len > 1 ? $$[1] : undefined, length) , end = $$len > 2 ? $$[2] : undefined , endPos = end === undefined ? length : toIndex(end, length); while(endPos > index)O[index++] = value; return O; }; },{"77":77,"80":80,"81":81}],8:[function(_dereq_,module,exports){ // false -> Array#indexOf // true -> Array#includes var toIObject = _dereq_(79) , toLength = _dereq_(80) , toIndex = _dereq_(77); 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; } return !IS_INCLUDES && -1; }; }; },{"77":77,"79":79,"80":80}],9:[function(_dereq_,module,exports){ // 0 -> Array#forEach // 1 -> Array#map // 2 -> Array#filter // 3 -> Array#some // 4 -> Array#every // 5 -> Array#find // 6 -> Array#findIndex var ctx = _dereq_(18) , IObject = _dereq_(35) , toObject = _dereq_(81) , toLength = _dereq_(80) , asc = _dereq_(10); 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 = toObject($this) , self = IObject(O) , f = ctx(callbackfn, that, 3) , length = toLength(self.length) , index = 0 , result = IS_MAP ? asc($this, length) : IS_FILTER ? asc($this, 0) : 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; // map else if(res)switch(TYPE){ case 3: return true; // some case 5: return val; // find case 6: return index; // findIndex case 2: result.push(val); // filter } else if(IS_EVERY)return false; // every } } return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result; }; }; },{"10":10,"18":18,"35":35,"80":80,"81":81}],10:[function(_dereq_,module,exports){ // 9.4.2.3 ArraySpeciesCreate(originalArray, length) var isObject = _dereq_(39) , isArray = _dereq_(37) , SPECIES = _dereq_(84)('species'); module.exports = function(original, length){ var C; if(isArray(original)){ C = original.constructor; // cross-realm fallback if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined; if(isObject(C)){ C = C[SPECIES]; if(C === null)C = undefined; } } return new (C === undefined ? Array : C)(length); }; },{"37":37,"39":39,"84":84}],11:[function(_dereq_,module,exports){ // getting tag from 19.1.3.6 Object.prototype.toString() var cof = _dereq_(12) , TAG = _dereq_(84)('toStringTag') // ES3 wrong here , ARG = cof(function(){ return arguments; }()) == 'Arguments'; module.exports = function(it){ var O, T, B; return it === undefined ? 'Undefined' : it === null ? 'Null' // @@toStringTag case : typeof (T = (O = Object(it))[TAG]) == 'string' ? T // builtinTag case : ARG ? cof(O) // ES3 arguments fallback : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; }; },{"12":12,"84":84}],12:[function(_dereq_,module,exports){ var toString = {}.toString; module.exports = function(it){ return toString.call(it).slice(8, -1); }; },{}],13:[function(_dereq_,module,exports){ 'use strict'; var $ = _dereq_(47) , hide = _dereq_(32) , redefineAll = _dereq_(61) , ctx = _dereq_(18) , strictNew = _dereq_(70) , defined = _dereq_(19) , forOf = _dereq_(28) , $iterDefine = _dereq_(43) , step = _dereq_(45) , ID = _dereq_(83)('id') , $has = _dereq_(31) , isObject = _dereq_(39) , setSpecies = _dereq_(66) , DESCRIPTORS = _dereq_(20) , isExtensible = Object.isExtensible || isObject , SIZE = DESCRIPTORS ? '_s' : 'size' , id = 0; 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, ID)){ // can't set id to frozen object if(!isExtensible(it))return 'F'; // not necessary to add id if(!create)return 'E'; // add missing object id hide(it, ID, ++id); // return object id with prefix } return 'O' + it[ID]; }; var getEntry = function(that, key){ // fast case var index = fastKey(key), entry; if(index !== 'F')return that._i[index]; // frozen object case for(entry = that._f; 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){ strictNew(that, C, NAME); that._i = $.create(null); // index that._f = undefined; // first entry that._l = undefined; // last entry that[SIZE] = 0; // size if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); }); redefineAll(C.prototype, { // 23.1.3.1 Map.prototype.clear() // 23.2.3.2 Set.prototype.clear() clear: function clear(){ for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){ entry.r = true; if(entry.p)entry.p = entry.p.n = undefined; delete data[entry.i]; } that._f = that._l = undefined; that[SIZE] = 0; }, // 23.1.3.3 Map.prototype.delete(key) // 23.2.3.4 Set.prototype.delete(value) 'delete': function(key){ var that = this , entry = getEntry(that, key); if(entry){ var next = entry.n , prev = entry.p; delete that._i[entry.i]; entry.r = true; if(prev)prev.n = next; if(next)next.p = prev; if(that._f == entry)that._f = next; if(that._l == entry)that._l = prev; that[SIZE]--; } return !!entry; }, // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) forEach: function forEach(callbackfn /*, that = undefined */){ var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3) , entry; while(entry = entry ? entry.n : this._f){ f(entry.v, entry.k, this); // revert to the last existing entry while(entry && entry.r)entry = entry.p; } }, // 23.1.3.7 Map.prototype.has(key) // 23.2.3.7 Set.prototype.has(value) has: function has(key){ return !!getEntry(this, key); } }); if(DESCRIPTORS)$.setDesc(C.prototype, 'size', { get: function(){ return defined(this[SIZE]); } }); return C; }, def: function(that, key, value){ var entry = getEntry(that, key) , prev, index; // change existing entry if(entry){ entry.v = value; // create new entry } else { that._l = entry = { i: index = fastKey(key, true), // <- index k: key, // <- key v: value, // <- value p: prev = that._l, // <- previous entry n: undefined, // <- next entry r: false // <- removed }; if(!that._f)that._f = entry; if(prev)prev.n = entry; that[SIZE]++; // add to index if(index !== 'F')that._i[index] = entry; } return that; }, getEntry: getEntry, setStrong: function(C, NAME, IS_MAP){ // add .keys, .values, .entries, [@@iterator] // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11 $iterDefine(C, NAME, function(iterated, kind){ this._t = iterated; // target this._k = kind; // kind this._l = undefined; // previous }, function(){ var that = this , kind = that._k , entry = that._l; // revert to the last existing entry while(entry && entry.r)entry = entry.p; // get next entry if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){ // or finish the iteration that._t = undefined; return step(1); } // return step by kind 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); // add [@@species], 23.1.2.2, 23.2.2.2 setSpecies(NAME); } }; },{"18":18,"19":19,"20":20,"28":28,"31":31,"32":32,"39":39,"43":43,"45":45,"47":47,"61":61,"66":66,"70":70,"83":83}],14:[function(_dereq_,module,exports){ // https://github.com/DavidBruant/Map-Set.prototype.toJSON var forOf = _dereq_(28) , classof = _dereq_(11); module.exports = function(NAME){ return function toJSON(){ if(classof(this) != NAME)throw TypeError(NAME + "#toJSON isn't generic"); var arr = []; forOf(this, false, arr.push, arr); return arr; }; }; },{"11":11,"28":28}],15:[function(_dereq_,module,exports){ 'use strict'; var hide = _dereq_(32) , redefineAll = _dereq_(61) , anObject = _dereq_(5) , isObject = _dereq_(39) , strictNew = _dereq_(70) , forOf = _dereq_(28) , createArrayMethod = _dereq_(9) , $has = _dereq_(31) , WEAK = _dereq_(83)('weak') , isExtensible = Object.isExtensible || isObject , arrayFind = createArrayMethod(5) , arrayFindIndex = createArrayMethod(6) , id = 0; // fallback for frozen keys var frozenStore = function(that){ return that._l || (that._l = new FrozenStore); }; var FrozenStore = function(){ this.a = []; }; var findFrozen = function(store, key){ return arrayFind(store.a, function(it){ return it[0] === key; }); }; FrozenStore.prototype = { 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.a.push([key, value]); }, 'delete': function(key){ var index = arrayFindIndex(this.a, function(it){ return it[0] === key; }); if(~index)this.a.splice(index, 1); return !!~index; } }; module.exports = { getConstructor: function(wrapper, NAME, IS_MAP, ADDER){ var C = wrapper(function(that, iterable){ strictNew(that, C, NAME); that._i = id++; // collection id that._l = undefined; // leak store for frozen objects if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); }); redefineAll(C.prototype, { // 23.3.3.2 WeakMap.prototype.delete(key) // 23.4.3.3 WeakSet.prototype.delete(value) 'delete': function(key){ if(!isObject(key))return false; if(!isExtensible(key))return frozenStore(this)['delete'](key); return $has(key, WEAK) && $has(key[WEAK], this._i) && delete key[WEAK][this._i]; }, // 23.3.3.4 WeakMap.prototype.has(key) // 23.4.3.4 WeakSet.prototype.has(value) has: function has(key){ if(!isObject(key))return false; if(!isExtensible(key))return frozenStore(this).has(key); return $has(key, WEAK) && $has(key[WEAK], this._i); } }); return C; }, def: function(that, key, value){ if(!isExtensible(anObject(key))){ frozenStore(that).set(key, value); } else { $has(key, WEAK) || hide(key, WEAK, {}); key[WEAK][that._i] = value; } return that; }, frozenStore: frozenStore, WEAK: WEAK }; },{"28":28,"31":31,"32":32,"39":39,"5":5,"61":61,"70":70,"83":83,"9":9}],16:[function(_dereq_,module,exports){ 'use strict'; var global = _dereq_(30) , $export = _dereq_(23) , redefine = _dereq_(62) , redefineAll = _dereq_(61) , forOf = _dereq_(28) , strictNew = _dereq_(70) , isObject = _dereq_(39) , fails = _dereq_(25) , $iterDetect = _dereq_(44) , setToStringTag = _dereq_(67); module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){ var Base = global[NAME] , C = Base , ADDER = IS_MAP ? 'set' : 'add' , proto = C && C.prototype , O = {}; var fixMethod = function(KEY){ var fn = proto[KEY]; redefine(proto, KEY, KEY == 'delete' ? function(a){ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); } : KEY == 'has' ? function has(a){ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a); } : KEY == 'get' ? function get(a){ return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a); } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; } : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; } ); }; if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){ new C().entries().next(); }))){ // create collection constructor C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER); redefineAll(C.prototype, methods); } else { var instance = new C // early implementations not supports chaining , HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); }) // most early implementations doesn't supports iterables, most modern - not close it correctly , ACCEPT_ITERABLES = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new // for early implementations -0 and +0 not the same , BUGGY_ZERO; if(!ACCEPT_ITERABLES){ C = wrapper(function(target, iterable){ strictNew(target, C, NAME); var that = new Base; if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that); return that; }); C.prototype = proto; proto.constructor = C; } IS_WEAK || instance.forEach(function(val, key){ BUGGY_ZERO = 1 / key === -Infinity; }); if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){ fixMethod('delete'); fixMethod('has'); IS_MAP && fixMethod('get'); } if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER); // weak collections should not contains .clear method if(IS_WEAK && proto.clear)delete proto.clear; } setToStringTag(C, NAME); O[NAME] = C; $export($export.G + $export.W + $export.F * (C != Base), O); if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP); return C; }; },{"23":23,"25":25,"28":28,"30":30,"39":39,"44":44,"61":61,"62":62,"67":67,"70":70}],17:[function(_dereq_,module,exports){ var core = module.exports = {version: '1.2.6'}; if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef },{}],18:[function(_dereq_,module,exports){ // optional / simple context binding var aFunction = _dereq_(3); 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); }; }; },{"3":3}],19:[function(_dereq_,module,exports){ // 7.2.1 RequireObjectCoercible(argument) module.exports = function(it){ if(it == undefined)throw TypeError("Can't call method on " + it); return it; }; },{}],20:[function(_dereq_,module,exports){ // Thank's IE8 for his funny defineProperty module.exports = !_dereq_(25)(function(){ return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; }); },{"25":25}],21:[function(_dereq_,module,exports){ var isObject = _dereq_(39) , document = _dereq_(30).document // in old IE typeof document.createElement is 'object' , is = isObject(document) && isObject(document.createElement); module.exports = function(it){ return is ? document.createElement(it) : {}; }; },{"30":30,"39":39}],22:[function(_dereq_,module,exports){ // all enumerable object keys, includes symbols var $ = _dereq_(47); module.exports = function(it){ var keys = $.getKeys(it) , getSymbols = $.getSymbols; if(getSymbols){ var symbols = getSymbols(it) , isEnum = $.isEnum , i = 0 , key; while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key); } return keys; }; },{"47":47}],23:[function(_dereq_,module,exports){ var global = _dereq_(30) , core = _dereq_(17) , hide = _dereq_(32) , redefine = _dereq_(62) , ctx = _dereq_(18) , 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 , target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE] , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) , expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}) , key, own, out, exp; if(IS_GLOBAL)source = name; for(key in source){ // contains in native own = !IS_FORCED && target && key in target; // export native or passed out = (own ? target : source)[key]; // bind timers to global for call from export context exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; // extend global if(target && !own)redefine(target, key, out); // export if(exports[key] != out)hide(exports, key, exp); if(IS_PROTO && expProto[key] != out)expProto[key] = out; } }; global.core = core; // 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 module.exports = $export; },{"17":17,"18":18,"30":30,"32":32,"62":62}],24:[function(_dereq_,module,exports){ var MATCH = _dereq_(84)('match'); module.exports = function(KEY){ var re = /./; try { '/./'[KEY](re); } catch(e){ try { re[MATCH] = false; return !'/./'[KEY](re); } catch(f){ /* empty */ } } return true; }; },{"84":84}],25:[function(_dereq_,module,exports){ module.exports = function(exec){ try { return !!exec(); } catch(e){ return true; } }; },{}],26:[function(_dereq_,module,exports){ 'use strict'; var hide = _dereq_(32) , redefine = _dereq_(62) , fails = _dereq_(25) , defined = _dereq_(19) , wks = _dereq_(84); module.exports = function(KEY, length, exec){ var SYMBOL = wks(KEY) , original = ''[KEY]; if(fails(function(){ var O = {}; O[SYMBOL] = function(){ return 7; }; return ''[KEY](O) != 7; })){ redefine(String.prototype, KEY, exec(defined, SYMBOL, original)); hide(RegExp.prototype, SYMBOL, length == 2 // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) // 21.2.5.11 RegExp.prototype[@@split](string, limit) ? function(string, arg){ return original.call(string, this, arg); } // 21.2.5.6 RegExp.prototype[@@match](string) // 21.2.5.9 RegExp.prototype[@@search](string) : function(string){ return original.call(string, this); } ); } }; },{"19":19,"25":25,"32":32,"62":62,"84":84}],27:[function(_dereq_,module,exports){ 'use strict'; // 21.2.5.3 get RegExp.prototype.flags var anObject = _dereq_(5); module.exports = function(){ var that = anObject(this) , result = ''; if(that.global) result += 'g'; if(that.ignoreCase) result += 'i'; if(that.multiline) result += 'm'; if(that.unicode) result += 'u'; if(that.sticky) result += 'y'; return result; }; },{"5":5}],28:[function(_dereq_,module,exports){ var ctx = _dereq_(18) , call = _dereq_(41) , isArrayIter = _dereq_(36) , anObject = _dereq_(5) , toLength = _dereq_(80) , getIterFn = _dereq_(85); module.exports = function(iterable, entries, fn, that){ var iterFn = getIterFn(iterable) , f = ctx(fn, that, entries ? 2 : 1) , index = 0 , length, step, iterator; if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!'); // fast case for arrays with default iterator if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){ entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){ call(iterator, f, step.value, entries); } }; },{"18":18,"36":36,"41":41,"5":5,"80":80,"85":85}],29:[function(_dereq_,module,exports){ // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window var toIObject = _dereq_(79) , getNames = _dereq_(47).getNames , toString = {}.toString; var windowNames = typeof window == 'object' && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : []; var getWindowNames = function(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(toIObject(it)); }; },{"47":47,"79":79}],30:[function(_dereq_,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 },{}],31:[function(_dereq_,module,exports){ var hasOwnProperty = {}.hasOwnProperty; module.exports = function(it, key){ return hasOwnProperty.call(it, key); }; },{}],32:[function(_dereq_,module,exports){ var $ = _dereq_(47) , createDesc = _dereq_(60); module.exports = _dereq_(20) ? function(object, key, value){ return $.setDesc(object, key, createDesc(1, value)); } : function(object, key, value){ object[key] = value; return object; }; },{"20":20,"47":47,"60":60}],33:[function(_dereq_,module,exports){ module.exports = _dereq_(30).document && document.documentElement; },{"30":30}],34:[function(_dereq_,module,exports){ // fast apply, http://jsperf.lnkit.com/fast-apply/5 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]); } return fn.apply(that, args); }; },{}],35:[function(_dereq_,module,exports){ // fallback for non-array-like ES3 and non-enumerable old V8 strings var cof = _dereq_(12); module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ return cof(it) == 'String' ? it.split('') : Object(it); }; },{"12":12}],36:[function(_dereq_,module,exports){ // check on default Array iterator var Iterators = _dereq_(46) , ITERATOR = _dereq_(84)('iterator') , ArrayProto = Array.prototype; module.exports = function(it){ return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it); }; },{"46":46,"84":84}],37:[function(_dereq_,module,exports){ // 7.2.2 IsArray(argument) var cof = _dereq_(12); module.exports = Array.isArray || function(arg){ return cof(arg) == 'Array'; }; },{"12":12}],38:[function(_dereq_,module,exports){ // 20.1.2.3 Number.isInteger(number) var isObject = _dereq_(39) , floor = Math.floor; module.exports = function isInteger(it){ return !isObject(it) && isFinite(it) && floor(it) === it; }; },{"39":39}],39:[function(_dereq_,module,exports){ module.exports = function(it){ return typeof it === 'object' ? it !== null : typeof it === 'function'; }; },{}],40:[function(_dereq_,module,exports){ // 7.2.8 IsRegExp(argument) var isObject = _dereq_(39) , cof = _dereq_(12) , MATCH = _dereq_(84)('match'); module.exports = function(it){ var isRegExp; return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp'); }; },{"12":12,"39":39,"84":84}],41:[function(_dereq_,module,exports){ // call something on iterator step with safe closing on error var anObject = _dereq_(5); module.exports = function(iterator, fn, value, entries){ try { return entries ? fn(anObject(value)[0], value[1]) : fn(value); // 7.4.6 IteratorClose(iterator, completion) } catch(e){ var ret = iterator['return']; if(ret !== undefined)anObject(ret.call(iterator)); throw e; } }; },{"5":5}],42:[function(_dereq_,module,exports){ 'use strict'; var $ = _dereq_(47) , descriptor = _dereq_(60) , setToStringTag = _dereq_(67) , IteratorPrototype = {}; // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() _dereq_(32)(IteratorPrototype, _dereq_(84)('iterator'), function(){ return this; }); module.exports = function(Constructor, NAME, next){ Constructor.prototype = $.create(IteratorPrototype, {next: descriptor(1, next)}); setToStringTag(Constructor, NAME + ' Iterator'); }; },{"32":32,"47":47,"60":60,"67":67,"84":84}],43:[function(_dereq_,module,exports){ 'use strict'; var LIBRARY = _dereq_(49) , $export = _dereq_(23) , redefine = _dereq_(62) , hide = _dereq_(32) , has = _dereq_(31) , Iterators = _dereq_(46) , $iterCreate = _dereq_(42) , setToStringTag = _dereq_(67) , getProto = _dereq_(47).getProto , ITERATOR = _dereq_(84)('iterator') , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next` , FF_ITERATOR = '@@iterator' , KEYS = 'keys' , VALUES = 'values'; var returnThis = function(){ return this; }; module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){ $iterCreate(Constructor, NAME, next); var getMethod = function(kind){ if(!BUGGY && kind in proto)return proto[kind]; switch(kind){ case KEYS: return function keys(){ return new Constructor(this, kind); }; case VALUES: return function values(){ return new Constructor(this, kind); }; } return function entries(){ return new Constructor(this, kind); }; }; var TAG = NAME + ' Iterator' , DEF_VALUES = DEFAULT == VALUES , VALUES_BUG = false , proto = Base.prototype , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT] , $default = $native || getMethod(DEFAULT) , methods, key; // Fix native if($native){ var IteratorPrototype = getProto($default.call(new Base)); // Set @@toStringTag to native iterators setToStringTag(IteratorPrototype, TAG, true); // FF fix if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis); // fix Array#{values, @@iterator}.name in V8 / FF if(DEF_VALUES && $native.name !== VALUES){ VALUES_BUG = true; $default = function values(){ return $native.call(this); }; } } // Define iterator if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){ hide(proto, ITERATOR, $default); } // Plug for library Iterators[NAME] = $default; Iterators[TAG] = returnThis; if(DEFAULT){ methods = { values: DEF_VALUES ? $default : getMethod(VALUES), keys: IS_SET ? $default : getMethod(KEYS), entries: !DEF_VALUES ? $default : getMethod('entries') }; if(FORCED)for(key in methods){ if(!(key in proto))redefine(proto, key, methods[key]); } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); } return methods; }; },{"23":23,"31":31,"32":32,"42":42,"46":46,"47":47,"49":49,"62":62,"67":67,"84":84}],44:[function(_dereq_,module,exports){ var ITERATOR = _dereq_(84)('iterator') , SAFE_CLOSING = false; try { var riter = [7][ITERATOR](); riter['return'] = function(){ SAFE_CLOSING = true; }; Array.from(riter, function(){ throw 2; }); } catch(e){ /* empty */ } module.exports = function(exec, skipClosing){ if(!skipClosing && !SAFE_CLOSING)return false; var safe = false; try { var arr = [7] , iter = arr[ITERATOR](); iter.next = function(){ safe = true; }; arr[ITERATOR] = function(){ return iter; }; exec(arr); } catch(e){ /* empty */ } return safe; }; },{"84":84}],45:[function(_dereq_,module,exports){ module.exports = function(done, value){ return {value: value, done: !!done}; }; },{}],46:[function(_dereq_,module,exports){ module.exports = {}; },{}],47:[function(_dereq_,module,exports){ var $Object = Object; module.exports = { create: $Object.create, getProto: $Object.getPrototypeOf, isEnum: {}.propertyIsEnumerable, getDesc: $Object.getOwnPropertyDescriptor, setDesc: $Object.defineProperty, setDescs: $Object.defineProperties, getKeys: $Object.keys, getNames: $Object.getOwnPropertyNames, getSymbols: $Object.getOwnPropertySymbols, each: [].forEach }; },{}],48:[function(_dereq_,module,exports){ var $ = _dereq_(47) , toIObject = _dereq_(79); 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":47,"79":79}],49:[function(_dereq_,module,exports){ module.exports = false; },{}],50:[function(_dereq_,module,exports){ // 20.2.2.14 Math.expm1(x) module.exports = Math.expm1 || function expm1(x){ return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1; }; },{}],51:[function(_dereq_,module,exports){ // 20.2.2.20 Math.log1p(x) module.exports = Math.log1p || function log1p(x){ return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x); }; },{}],52:[function(_dereq_,module,exports){ // 20.2.2.28 Math.sign(x) module.exports = Math.sign || function sign(x){ return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1; }; },{}],53:[function(_dereq_,module,exports){ var global = _dereq_(30) , macrotask = _dereq_(76).set , Observer = global.MutationObserver || global.WebKitMutationObserver , process = global.process , Promise = global.Promise , isNode = _dereq_(12)(process) == 'process' , head, last, notify; var flush = function(){ var parent, domain, fn; if(isNode && (parent = process.domain)){ process.domain = null; parent.exit(); } while(head){ domain = head.domain; fn = head.fn; if(domain)domain.enter(); fn(); // <- currently we use it only for Promise - try / catch not required if(domain)domain.exit(); head = head.next; } last = undefined; if(parent)parent.enter(); }; // Node.js if(isNode){ notify = function(){ process.nextTick(flush); }; // browsers with MutationObserver } else if(Observer){ var toggle = 1 , node = document.createTextNode(''); new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new notify = function(){ node.data = toggle = -toggle; }; // environments with maybe non-completely correct, but existent Promise } else if(Promise && Promise.resolve){ notify = function(){ Promise.resolve().then(flush); }; // for other environments - macrotask based on: // - setImmediate // - MessageChannel // - window.postMessag // - onreadystatechange // - setTimeout } else { notify = function(){ // strange IE + webpack dev server bug - use .call(global) macrotask.call(global, flush); }; } module.exports = function asap(fn){ var task = {fn: fn, next: undefined, domain: isNode && process.domain}; if(last)last.next = task; if(!head){ head = task; notify(); } last = task; }; },{"12":12,"30":30,"76":76}],54:[function(_dereq_,module,exports){ // 19.1.2.1 Object.assign(target, source, ...) var $ = _dereq_(47) , toObject = _dereq_(81) , IObject = _dereq_(35); // should work with symbols and should have deterministic property order (V8 bug) module.exports = _dereq_(25)(function(){ var a = Object.assign , A = {} , B = {} , S = Symbol() , K = 'abcdefghijklmnopqrst'; A[S] = 7; K.split('').forEach(function(k){ B[k] = k; }); return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K; }) ? function assign(target, source){ // eslint-disable-line no-unused-vars var T = toObject(target) , $$ = arguments , $$len = $$.length , index = 1 , getKeys = $.getKeys , getSymbols = $.getSymbols , isEnum = $.isEnum; while($$len > index){ var S = IObject($$[index++]) , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S) , length = keys.length , j = 0 , key; while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key]; } return T; } : Object.assign; },{"25":25,"35":35,"47":47,"81":81}],55:[function(_dereq_,module,exports){ // most Object methods by ES6 should accept primitives var $export = _dereq_(23) , core = _dereq_(17) , fails = _dereq_(25); 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); }; },{"17":17,"23":23,"25":25}],56:[function(_dereq_,module,exports){ var $ = _dereq_(47) , toIObject = _dereq_(79) , isEnum = $.isEnum; module.exports = function(isEntries){ return function(it){ var O = toIObject(it) , keys = $.getKeys(O) , length = keys.length , i = 0 , result = [] , key; while(length > i)if(isEnum.call(O, key = keys[i++])){ result.push(isEntries ? [key, O[key]] : O[key]); } return result; }; }; },{"47":47,"79":79}],57:[function(_dereq_,module,exports){ // all object keys, includes non-enumerable and symbols var $ = _dereq_(47) , anObject = _dereq_(5) , Reflect = _dereq_(30).Reflect; module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){ var keys = $.getNames(anObject(it)) , getSymbols = $.getSymbols; return getSymbols ? keys.concat(getSymbols(it)) : keys; }; },{"30":30,"47":47,"5":5}],58:[function(_dereq_,module,exports){ 'use strict'; var path = _dereq_(59) , invoke = _dereq_(34) , aFunction = _dereq_(3); module.exports = function(/* ...pargs */){ var fn = aFunction(this) , length = arguments.length , pargs = Array(length) , i = 0 , _ = path._ , holder = false; while(length > i)if((pargs[i] = arguments[i++]) === _)holder = true; return function(/* ...args */){ var that = this , $$ = arguments , $$len = $$.length , j = 0, k = 0, args; if(!holder && !$$len)return invoke(fn, pargs, that); args = pargs.slice(); if(holder)for(;length > j; j++)if(args[j] === _)args[j] = $$[k++]; while($$len > k)args.push($$[k++]); return invoke(fn, args, that); }; }; },{"3":3,"34":34,"59":59}],59:[function(_dereq_,module,exports){ module.exports = _dereq_(30); },{"30":30}],60:[function(_dereq_,module,exports){ module.exports = function(bitmap, value){ return { enumerable : !(bitmap & 1), configurable: !(bitmap & 2), writable : !(bitmap & 4), value : value }; }; },{}],61:[function(_dereq_,module,exports){ var redefine = _dereq_(62); module.exports = function(target, src){ for(var key in src)redefine(target, key, src[key]); return target; }; },{"62":62}],62:[function(_dereq_,module,exports){ // add fake Function#toString // for correct work wrapped methods / constructors with methods like LoDash isNative var global = _dereq_(30) , hide = _dereq_(32) , SRC = _dereq_(83)('src') , TO_STRING = 'toString' , $toString = Function[TO_STRING] , TPL = ('' + $toString).split(TO_STRING); _dereq_(17).inspectSource = function(it){ return $toString.call(it); }; (module.exports = function(O, key, val, safe){ if(typeof val == 'function'){ val.hasOwnProperty(SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); val.hasOwnProperty('name') || hide(val, 'name', key); } if(O === global){ O[key] = val; } else { if(!safe)delete O[key]; hide(O, key, val); } })(Function.prototype, TO_STRING, function toString(){ return typeof this == 'function' && this[SRC] || $toString.call(this); }); },{"17":17,"30":30,"32":32,"83":83}],63:[function(_dereq_,module,exports){ module.exports = function(regExp, replace){ var replacer = replace === Object(replace) ? function(part){ return replace[part]; } : replace; return function(it){ return String(it).replace(regExp, replacer); }; }; },{}],64:[function(_dereq_,module,exports){ // 7.2.9 SameValue(x, y) module.exports = Object.is || function is(x, y){ return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; }; },{}],65:[function(_dereq_,module,exports){ // Works with __proto__ only. Old v8 can't work with null proto objects. /* eslint-disable no-proto */ var getDesc = _dereq_(47).getDesc , isObject = _dereq_(39) , anObject = _dereq_(5); var check = function(O, proto){ anObject(O); if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!"); }; module.exports = { set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line function(test, buggy, set){ try { set = _dereq_(18)(Function.call, getDesc(Object.prototype, '__proto__').set, 2); set(test, []); buggy = !(test instanceof Array); } catch(e){ buggy = true; } return function setPrototypeOf(O, proto){ check(O, proto); if(buggy)O.__proto__ = proto; else set(O, proto); return O; }; }({}, false) : undefined), check: check }; },{"18":18,"39":39,"47":47,"5":5}],66:[function(_dereq_,module,exports){ 'use strict'; var global = _dereq_(30) , $ = _dereq_(47) , DESCRIPTORS = _dereq_(20) , SPECIES = _dereq_(84)('species'); module.exports = function(KEY){ var C = global[KEY]; if(DESCRIPTORS && C && !C[SPECIES])$.setDesc(C, SPECIES, { configurable: true, get: function(){ return this; } }); }; },{"20":20,"30":30,"47":47,"84":84}],67:[function(_dereq_,module,exports){ var def = _dereq_(47).setDesc , has = _dereq_(31) , TAG = _dereq_(84)('toStringTag'); module.exports = function(it, tag, stat){ if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag}); }; },{"31":31,"47":47,"84":84}],68:[function(_dereq_,module,exports){ var global = _dereq_(30) , SHARED = '__core-js_shared__' , store = global[SHARED] || (global[SHARED] = {}); module.exports = function(key){ return store[key] || (store[key] = {}); }; },{"30":30}],69:[function(_dereq_,module,exports){ // 7.3.20 SpeciesConstructor(O, defaultConstructor) var anObject = _dereq_(5) , aFunction = _dereq_(3) , SPECIES = _dereq_(84)('species'); module.exports = function(O, D){ var C = anObject(O).constructor, S; return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); }; },{"3":3,"5":5,"84":84}],70:[function(_dereq_,module,exports){ module.exports = function(it, Constructor, name){ if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!"); return it; }; },{}],71:[function(_dereq_,module,exports){ var toInteger = _dereq_(78) , defined = _dereq_(19); // true -> String#at // false -> String#codePointAt module.exports = function(TO_STRING){ return function(that, pos){ var s = String(defined(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; }; }; },{"19":19,"78":78}],72:[function(_dereq_,module,exports){ // helper for String#{startsWith, endsWith, includes} var isRegExp = _dereq_(40) , defined = _dereq_(19); module.exports = function(that, searchString, NAME){ if(isRegExp(searchString))throw TypeError('String#' + NAME + " doesn't accept regex!"); return String(defined(that)); }; },{"19":19,"40":40}],73:[function(_dereq_,module,exports){ // https://github.com/ljharb/proposal-string-pad-left-right var toLength = _dereq_(80) , repeat = _dereq_(74) , defined = _dereq_(19); module.exports = function(that, maxLength, fillString, left){ var S = String(defined(that)) , stringLength = S.length , fillStr = fillString === undefined ? ' ' : String(fillString) , intMaxLength = toLength(maxLength); if(intMaxLength <= stringLength)return S; if(fillStr == '')fillStr = ' '; var fillLen = intMaxLength - stringLength , stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length)); if(stringFiller.length > fillLen)stringFiller = stringFiller.slice(0, fillLen); return left ? stringFiller + S : S + stringFiller; }; },{"19":19,"74":74,"80":80}],74:[function(_dereq_,module,exports){ 'use strict'; var toInteger = _dereq_(78) , defined = _dereq_(19); module.exports = function repeat(count){ var str = String(defined(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; }; },{"19":19,"78":78}],75:[function(_dereq_,module,exports){ var $export = _dereq_(23) , defined = _dereq_(19) , fails = _dereq_(25) , spaces = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF' , space = '[' + spaces + ']' , non = '\u200b\u0085' , ltrim = RegExp('^' + space + space + '*') , rtrim = RegExp(space + space + '*$'); var exporter = function(KEY, exec){ var exp = {}; exp[KEY] = exec(trim); $export($export.P + $export.F * fails(function(){ return !!spaces[KEY]() || non[KEY]() != non; }), 'String', exp); }; // 1 -> String#trimLeft // 2 -> String#trimRight // 3 -> String#trim var trim = exporter.trim = function(string, TYPE){ string = String(defined(string)); if(TYPE & 1)string = string.replace(ltrim, ''); if(TYPE & 2)string = string.replace(rtrim, ''); return string; }; module.exports = exporter; },{"19":19,"23":23,"25":25}],76:[function(_dereq_,module,exports){ var ctx = _dereq_(18) , invoke = _dereq_(34) , html = _dereq_(33) , cel = _dereq_(21) , global = _dereq_(30) , process = global.process , setTask = global.setImmediate , clearTask = global.clearImmediate , MessageChannel = global.MessageChannel , counter = 0 , queue = {} , ONREADYSTATECHANGE = 'onreadystatechange' , defer, channel, port; var run = function(){ var id = +this; if(queue.hasOwnProperty(id)){ var fn = queue[id]; delete queue[id]; fn(); } }; var listner = function(event){ run.call(event.data); }; // Node.js 0.9+ & IE10+ has setImmediate, otherwise: if(!setTask || !clearTask){ setTask = function setImmediate(fn){ var args = [], i = 1; while(arguments.length > i)args.push(arguments[i++]); queue[++counter] = function(){ invoke(typeof fn == 'function' ? fn : Function(fn), args); }; defer(counter); return counter; }; clearTask = function clearImmediate(id){ delete queue[id]; }; // Node.js 0.8- if(_dereq_(12)(process) == 'process'){ defer = function(id){ process.nextTick(ctx(run, id, 1)); }; // Browsers with MessageChannel, includes WebWorkers } else if(MessageChannel){ channel = new MessageChannel; port = channel.port2; channel.port1.onmessage = listner; defer = ctx(port.postMessage, port, 1); // Browsers with postMessage, skip WebWorkers // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){ defer = function(id){ global.postMessage(id + '', '*'); }; global.addEventListener('message', listner, false); // IE8- } else if(ONREADYSTATECHANGE in cel('script')){ defer = function(id){ html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){ html.removeChild(this); run.call(id); }; }; // Rest old browsers } else { defer = function(id){ setTimeout(ctx(run, id, 1), 0); }; } } module.exports = { set: setTask, clear: clearTask }; },{"12":12,"18":18,"21":21,"30":30,"33":33,"34":34}],77:[function(_dereq_,module,exports){ var toInteger = _dereq_(78) , max = Math.max , min = Math.min; module.exports = function(index, length){ index = toInteger(index); return index < 0 ? max(index + length, 0) : min(index, length); }; },{"78":78}],78:[function(_dereq_,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); }; },{}],79:[function(_dereq_,module,exports){ // to indexed object, toObject with fallback for non-array-like ES3 strings var IObject = _dereq_(35) , defined = _dereq_(19); module.exports = function(it){ return IObject(defined(it)); }; },{"19":19,"35":35}],80:[function(_dereq_,module,exports){ // 7.1.15 ToLength var toInteger = _dereq_(78) , min = Math.min; module.exports = function(it){ return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 }; },{"78":78}],81:[function(_dereq_,module,exports){ // 7.1.13 ToObject(argument) var defined = _dereq_(19); module.exports = function(it){ return Object(defined(it)); }; },{"19":19}],82:[function(_dereq_,module,exports){ // 7.1.1 ToPrimitive(input [, PreferredType]) var isObject = _dereq_(39); // 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"); }; },{"39":39}],83:[function(_dereq_,module,exports){ var id = 0 , px = Math.random(); module.exports = function(key){ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); }; },{}],84:[function(_dereq_,module,exports){ var store = _dereq_(68)('wks') , uid = _dereq_(83) , Symbol = _dereq_(30).Symbol; module.exports = function(name){ return store[name] || (store[name] = Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name)); }; },{"30":30,"68":68,"83":83}],85:[function(_dereq_,module,exports){ var classof = _dereq_(11) , ITERATOR = _dereq_(84)('iterator') , Iterators = _dereq_(46); module.exports = _dereq_(17).getIteratorMethod = function(it){ if(it != undefined)return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)]; }; },{"11":11,"17":17,"46":46,"84":84}],86:[function(_dereq_,module,exports){ 'use strict'; var $ = _dereq_(47) , $export = _dereq_(23) , DESCRIPTORS = _dereq_(20) , createDesc = _dereq_(60) , html = _dereq_(33) , cel = _dereq_(21) , has = _dereq_(31) , cof = _dereq_(12) , invoke = _dereq_(34) , fails = _dereq_(25) , anObject = _dereq_(5) , aFunction = _dereq_(3) , isObject = _dereq_(39) , toObject = _dereq_(81) , toIObject = _dereq_(79) , toInteger = _dereq_(78) , toIndex = _dereq_(77) , toLength = _dereq_(80) , IObject = _dereq_(35) , IE_PROTO = _dereq_(83)('__proto__') , createArrayMethod = _dereq_(9) , arrayIndexOf = _dereq_(8)(false) , ObjectProto = Object.prototype , ArrayProto = Array.prototype , arraySlice = ArrayProto.slice , arrayJoin = ArrayProto.join , defineProperty = $.setDesc , getOwnDescriptor = $.getDesc , defineProperties = $.setDescs , factories = {} , IE8_DOM_DEFINE; if(!DESCRIPTORS){ IE8_DOM_DEFINE = !fails(function(){ return defineProperty(cel('div'), 'a', {get: function(){ return 7; }}).a != 7; }); $.setDesc = function(O, P, Attributes){ if(IE8_DOM_DEFINE)try { return defineProperty(O, P, Attributes); } catch(e){ /* empty */ } if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); if('value' in Attributes)anObject(O)[P] = Attributes.value; return O; }; $.getDesc = function(O, P){ if(IE8_DOM_DEFINE)try { return getOwnDescriptor(O, P); } catch(e){ /* empty */ } if(has(O, P))return createDesc(!ObjectProto.propertyIsEnumerable.call(O, P), O[P]); }; $.setDescs = defineProperties = function(O, Properties){ anObject(O); var keys = $.getKeys(Properties) , length = keys.length , i = 0 , P; while(length > i)$.setDesc(O, P = keys[i++], Properties[P]); return O; }; } $export($export.S + $export.F * !DESCRIPTORS, 'Object', { // 19.1.2.6 / 15.2.3.3 Object.getOwnPropertyDescriptor(O, P) getOwnPropertyDescriptor: $.getDesc, // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) defineProperty: $.setDesc, // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties) defineProperties: defineProperties }); // IE 8- don't enum bug keys var keys1 = ('constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,' + 'toLocaleString,toString,valueOf').split(',') // Additional keys for getOwnPropertyNames , keys2 = keys1.concat('length', 'prototype') , keysLen1 = keys1.length; // Create object with `null` prototype: use iframe Object with cleared prototype var createDict = function(){ // Thrash, waste and sodomy: IE GC bug var iframe = cel('iframe') , i = keysLen1 , gt = '>' , iframeDocument; iframe.style.display = 'none'; html.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('