diff --git a/build/cjs/vcdiff-decoder.js b/build/cjs/vcdiff-decoder.js new file mode 100644 index 0000000..0d8a40c --- /dev/null +++ b/build/cjs/vcdiff-decoder.js @@ -0,0 +1,6123 @@ +(function(e, a) { for(var i in a) e[i] = a[i]; }(exports, /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.decode = decode; +var _vcdiff = _interopRequireDefault(__webpack_require__(46)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +/** + * Vcdiff decode, applying delta to source and returning the result. + * + * @param delta {Uint8Array} The Vcdiff format diff/patch to apply to source. + * @param source {Uint8Array} The source to apply the delta diff/patch to. + * @returns {Uint8Array} The result of applying delta to source. + */ +function decode(delta, source) { + var vcdiff = new _vcdiff["default"](delta, source); + return vcdiff.decode(); +} + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var objectDefinePropertyModile = __webpack_require__(20); + +// `Object.defineProperty` method +// https://tc39.github.io/ecma262/#sec-object.defineproperty +$({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, { + defineProperty: objectDefinePropertyModile.f +}); + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var setGlobal = __webpack_require__(23); +var copyConstructorProperties = __webpack_require__(33); +var isForced = __webpack_require__(45); + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.noTargetGet - prevent calling a getter on target +*/ +module.exports = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global; + } else if (STATIC) { + target = global[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty === typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + // extend global + redefine(target, key, sourceProperty, options); + } +}; + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(global) {var check = function (it) { + return it && it.Math == Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +module.exports = + // eslint-disable-next-line no-undef + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + check(typeof self == 'object' && self) || + check(typeof global == 'object' && global) || + // eslint-disable-next-line no-new-func + Function('return this')(); + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(4))) + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + +var g; + +// This works in non-strict mode +g = (function() { + return this; +})(); + +try { + // This works if eval is allowed (see CSP) + g = g || new Function("return this")(); +} catch (e) { + // This works if the window reference is available + if (typeof window === "object") g = window; +} + +// g can still be undefined, but nothing to do about it... +// We return undefined, instead of nothing here, so it's +// easier to handle this case. if(!global) { ...} + +module.exports = g; + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var propertyIsEnumerableModule = __webpack_require__(8); +var createPropertyDescriptor = __webpack_require__(9); +var toIndexedObject = __webpack_require__(10); +var toPrimitive = __webpack_require__(14); +var has = __webpack_require__(16); +var IE8_DOM_DEFINE = __webpack_require__(17); + +var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor +exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) try { + return nativeGetOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); +}; + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +// Thank's IE8 for his funny defineProperty +module.exports = !fails(function () { + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; +}); + + +/***/ }), +/* 7 */ +/***/ (function(module, exports) { + +module.exports = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var nativePropertyIsEnumerable = {}.propertyIsEnumerable; +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable +exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : nativePropertyIsEnumerable; + + +/***/ }), +/* 9 */ +/***/ (function(module, exports) { + +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject = __webpack_require__(11); +var requireObjectCoercible = __webpack_require__(13); + +module.exports = function (it) { + return IndexedObject(requireObjectCoercible(it)); +}; + + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); +var classof = __webpack_require__(12); + +var split = ''.split; + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +module.exports = fails(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins + return !Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof(it) == 'String' ? split.call(it, '') : Object(it); +} : Object; + + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + +var toString = {}.toString; + +module.exports = function (it) { + return toString.call(it).slice(8, -1); +}; + + +/***/ }), +/* 13 */ +/***/ (function(module, exports) { + +// `RequireObjectCoercible` abstract operation +// https://tc39.github.io/ecma262/#sec-requireobjectcoercible +module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); + +// `ToPrimitive` abstract operation +// https://tc39.github.io/ecma262/#sec-toprimitive +// 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 (input, PREFERRED_STRING) { + if (!isObject(input)) return input; + var fn, val; + if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; + if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val; + if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; + throw TypeError("Can't convert object to primitive value"); +}; + + +/***/ }), +/* 15 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + +var hasOwnProperty = {}.hasOwnProperty; + +module.exports = function (it, key) { + return hasOwnProperty.call(it, key); +}; + + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var createElement = __webpack_require__(18); + +// Thank's IE8 for his funny defineProperty +module.exports = !DESCRIPTORS && !fails(function () { + return Object.defineProperty(createElement('div'), 'a', { + get: function () { return 7; } + }).a != 7; +}); + + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); + +var document = global.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject(document) && isObject(document.createElement); + +module.exports = function (it) { + return EXISTS ? document.createElement(it) : {}; +}; + + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(20); +var createPropertyDescriptor = __webpack_require__(9); + +module.exports = DESCRIPTORS ? function (object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var IE8_DOM_DEFINE = __webpack_require__(17); +var anObject = __webpack_require__(21); +var toPrimitive = __webpack_require__(14); + +var nativeDefineProperty = Object.defineProperty; + +// `Object.defineProperty` method +// https://tc39.github.io/ecma262/#sec-object.defineproperty +exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return nativeDefineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); + +module.exports = function (it) { + if (!isObject(it)) { + throw TypeError(String(it) + ' is not an object'); + } return it; +}; + + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var createNonEnumerableProperty = __webpack_require__(19); +var has = __webpack_require__(16); +var setGlobal = __webpack_require__(23); +var inspectSource = __webpack_require__(24); +var InternalStateModule = __webpack_require__(26); + +var getInternalState = InternalStateModule.get; +var enforceInternalState = InternalStateModule.enforce; +var TEMPLATE = String(String).split('String'); + +(module.exports = function (O, key, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + if (typeof value == 'function') { + if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key); + enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); + } + if (O === global) { + if (simple) O[key] = value; + else setGlobal(key, value); + return; + } else if (!unsafe) { + delete O[key]; + } else if (!noTargetGet && O[key]) { + simple = true; + } + if (simple) O[key] = value; + else createNonEnumerableProperty(O, key, value); +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +})(Function.prototype, 'toString', function toString() { + return typeof this == 'function' && getInternalState(this).source || inspectSource(this); +}); + + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var createNonEnumerableProperty = __webpack_require__(19); + +module.exports = function (key, value) { + try { + createNonEnumerableProperty(global, key, value); + } catch (error) { + global[key] = value; + } return value; +}; + + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __webpack_require__) { + +var store = __webpack_require__(25); + +var functionToString = Function.toString; + +// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper +if (typeof store.inspectSource != 'function') { + store.inspectSource = function (it) { + return functionToString.call(it); + }; +} + +module.exports = store.inspectSource; + + +/***/ }), +/* 25 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var setGlobal = __webpack_require__(23); + +var SHARED = '__core-js_shared__'; +var store = global[SHARED] || setGlobal(SHARED, {}); + +module.exports = store; + + +/***/ }), +/* 26 */ +/***/ (function(module, exports, __webpack_require__) { + +var NATIVE_WEAK_MAP = __webpack_require__(27); +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); +var createNonEnumerableProperty = __webpack_require__(19); +var objectHas = __webpack_require__(16); +var sharedKey = __webpack_require__(28); +var hiddenKeys = __webpack_require__(32); + +var WeakMap = global.WeakMap; +var set, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP) { + var store = new WeakMap(); + var wmget = store.get; + var wmhas = store.has; + var wmset = store.set; + set = function (it, metadata) { + wmset.call(store, it, metadata); + return metadata; + }; + get = function (it) { + return wmget.call(store, it) || {}; + }; + has = function (it) { + return wmhas.call(store, it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return objectHas(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return objectHas(it, STATE); + }; +} + +module.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + + +/***/ }), +/* 27 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var inspectSource = __webpack_require__(24); + +var WeakMap = global.WeakMap; + +module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap)); + + +/***/ }), +/* 28 */ +/***/ (function(module, exports, __webpack_require__) { + +var shared = __webpack_require__(29); +var uid = __webpack_require__(31); + +var keys = shared('keys'); + +module.exports = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + + +/***/ }), +/* 29 */ +/***/ (function(module, exports, __webpack_require__) { + +var IS_PURE = __webpack_require__(30); +var store = __webpack_require__(25); + +(module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.6.5', + mode: IS_PURE ? 'pure' : 'global', + copyright: '© 2020 Denis Pushkarev (zloirock.ru)' +}); + + +/***/ }), +/* 30 */ +/***/ (function(module, exports) { + +module.exports = false; + + +/***/ }), +/* 31 */ +/***/ (function(module, exports) { + +var id = 0; +var postfix = Math.random(); + +module.exports = function (key) { + return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); +}; + + +/***/ }), +/* 32 */ +/***/ (function(module, exports) { + +module.exports = {}; + + +/***/ }), +/* 33 */ +/***/ (function(module, exports, __webpack_require__) { + +var has = __webpack_require__(16); +var ownKeys = __webpack_require__(34); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(20); + +module.exports = function (target, source) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } +}; + + +/***/ }), +/* 34 */ +/***/ (function(module, exports, __webpack_require__) { + +var getBuiltIn = __webpack_require__(35); +var getOwnPropertyNamesModule = __webpack_require__(37); +var getOwnPropertySymbolsModule = __webpack_require__(44); +var anObject = __webpack_require__(21); + +// all object keys, includes non-enumerable and symbols +module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; +}; + + +/***/ }), +/* 35 */ +/***/ (function(module, exports, __webpack_require__) { + +var path = __webpack_require__(36); +var global = __webpack_require__(3); + +var aFunction = function (variable) { + return typeof variable == 'function' ? variable : undefined; +}; + +module.exports = function (namespace, method) { + return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) + : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; +}; + + +/***/ }), +/* 36 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); + +module.exports = global; + + +/***/ }), +/* 37 */ +/***/ (function(module, exports, __webpack_require__) { + +var internalObjectKeys = __webpack_require__(38); +var enumBugKeys = __webpack_require__(43); + +var hiddenKeys = enumBugKeys.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertynames +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); +}; + + +/***/ }), +/* 38 */ +/***/ (function(module, exports, __webpack_require__) { + +var has = __webpack_require__(16); +var toIndexedObject = __webpack_require__(10); +var indexOf = __webpack_require__(39).indexOf; +var hiddenKeys = __webpack_require__(32); + +module.exports = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~indexOf(result, key) || result.push(key); + } + return result; +}; + + +/***/ }), +/* 39 */ +/***/ (function(module, exports, __webpack_require__) { + +var toIndexedObject = __webpack_require__(10); +var toLength = __webpack_require__(40); +var toAbsoluteIndex = __webpack_require__(42); + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +module.exports = { + // `Array.prototype.includes` method + // https://tc39.github.io/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.github.io/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + + +/***/ }), +/* 40 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(41); + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.github.io/ecma262/#sec-tolength +module.exports = function (argument) { + return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + + +/***/ }), +/* 41 */ +/***/ (function(module, exports) { + +var ceil = Math.ceil; +var floor = Math.floor; + +// `ToInteger` abstract operation +// https://tc39.github.io/ecma262/#sec-tointeger +module.exports = function (argument) { + return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); +}; + + +/***/ }), +/* 42 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(41); + +var max = Math.max; +var min = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +module.exports = function (index, length) { + var integer = toInteger(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); +}; + + +/***/ }), +/* 43 */ +/***/ (function(module, exports) { + +// IE8- don't enum bug keys +module.exports = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + + +/***/ }), +/* 44 */ +/***/ (function(module, exports) { + +exports.f = Object.getOwnPropertySymbols; + + +/***/ }), +/* 45 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true + : value == NATIVE ? false + : typeof detection == 'function' ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +module.exports = isForced; + + +/***/ }), +/* 46 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(53); +__webpack_require__(69); +__webpack_require__(73); +__webpack_require__(93); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(94); +__webpack_require__(98); +__webpack_require__(71); +__webpack_require__(100); +__webpack_require__(107); +__webpack_require__(115); +__webpack_require__(117); +__webpack_require__(118); +__webpack_require__(119); +__webpack_require__(120); +__webpack_require__(121); +__webpack_require__(122); +__webpack_require__(123); +__webpack_require__(124); +__webpack_require__(125); +__webpack_require__(126); +__webpack_require__(127); +__webpack_require__(129); +__webpack_require__(130); +__webpack_require__(131); +__webpack_require__(132); +__webpack_require__(133); +__webpack_require__(134); +__webpack_require__(135); +__webpack_require__(136); +__webpack_require__(137); +__webpack_require__(138); +__webpack_require__(139); +__webpack_require__(140); +__webpack_require__(145); +__webpack_require__(147); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(154); +var _errors = _interopRequireDefault(__webpack_require__(157)); +var TypedArray = _interopRequireWildcard(__webpack_require__(160)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var _delta = _interopRequireDefault(__webpack_require__(171)); +var _near = _interopRequireDefault(__webpack_require__(174)); +var _same = _interopRequireDefault(__webpack_require__(176)); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +/** + * + * @param delta {Uint8Array} + * @param source {Uint8Array} + * @constructor + */ +var VCDiff = exports["default"] = /*#__PURE__*/function () { + function VCDiff(delta, source) { + _classCallCheck(this, VCDiff); + this.delta = delta; + this.position = 0; + this.source = source; + this.targetWindows = new TypedArray.TypedArrayList(); + } + _createClass(VCDiff, [{ + key: "decode", + value: function decode() { + this._consumeHeader(); + while (this._consumeWindow()) {} + var targetLength = this.targetWindows.typedArrays.reduce(function (sum, uint8Array) { + return uint8Array.length + sum; + }, 0); + var target = new Uint8Array(targetLength); + var position = 0; + + // concat all uint8arrays + for (var arrayNum = 0; arrayNum < this.targetWindows.typedArrays.length; arrayNum++) { + var array = this.targetWindows.typedArrays[arrayNum]; + var length = array.length; + target.set(array, position); + position += length; + } + return target; + } + }, { + key: "_consumeHeader", + value: function _consumeHeader() { + var hasVCDiffHeader = this.delta[0] === 214 && + // V + this.delta[1] === 195 && + // C + this.delta[2] === 196 && + // D + this.delta[3] === 0; // \0 + + if (!hasVCDiffHeader) { + throw new _errors["default"].InvalidDelta('first 3 bytes not VCD'); + } + var hdrIndicator = this.delta[4]; + // extract least significant bit + var vcdDecompress = 1 & hdrIndicator; + // extract second least significant bit + var vcdCodetable = 1 & hdrIndicator >> 1; + + // verify not using Hdr_Indicator + if (vcdDecompress || vcdCodetable) { + throw new _errors["default"].NotImplemented('non-zero Hdr_Indicator (VCD_DECOMPRESS or VCD_CODETABLE bit is set)'); + } + this.position += 5; + } + }, { + key: "_consumeWindow", + value: function _consumeWindow() { + var winIndicator = this.delta[this.position++]; + + // extract least significant bit + var vcdSource = 1 & winIndicator; + // extract second least significant bit + var vcdTarget = 1 & winIndicator >> 1; + if (vcdSource && vcdTarget) { + throw new _errors["default"].InvalidDelta('VCD_SOURCE and VCD_TARGET cannot both be set in Win_Indicator'); + } else if (vcdSource) { + var sourceSegmentLength, sourceSegmentPosition, deltaLength; + var _deserializeInteger = (0, _integer["default"])(this.delta, this.position); + sourceSegmentLength = _deserializeInteger.value; + this.position = _deserializeInteger.position; + var _deserializeInteger2 = (0, _integer["default"])(this.delta, this.position); + sourceSegmentPosition = _deserializeInteger2.value; + this.position = _deserializeInteger2.position; + var _deserializeInteger3 = (0, _integer["default"])(this.delta, this.position); + deltaLength = _deserializeInteger3.value; + this.position = _deserializeInteger3.position; + var sourceSegment = this.source.slice(sourceSegmentPosition, sourceSegmentPosition + sourceSegmentLength); + this._buildTargetWindow(this.position, sourceSegment); + this.position += deltaLength; + } else if (vcdTarget) { + throw new _errors["default"].NotImplemented('non-zero VCD_TARGET in Win_Indicator'); + } else { + var _deltaLength; + var _deserializeInteger4 = (0, _integer["default"])(this.delta, this.position); + _deltaLength = _deserializeInteger4.value; + this.position = _deserializeInteger4.position; + this._buildTargetWindow(this.position); + this.position += _deltaLength; + } + return this.position < this.delta.length; + } + }, { + key: "_buildTargetWindow", + value: + // first integer is target window length + function _buildTargetWindow(position, sourceSegment) { + var window = (0, _delta["default"])(this.delta, position); + var T = new Uint8Array(window.targetWindowLength); + var U = new TypedArray.TypedArrayList(); + var uTargetPosition = 0; + if (sourceSegment) { + U.add(sourceSegment); + uTargetPosition = sourceSegment.length; + } + U.add(T); + var targetPosition = this.source.length; + var dataPosition = 0; + var delta = new Delta(U, uTargetPosition, window.data, window.addresses); + window.instructions.forEach(function (instruction) { + instruction.execute(delta); + }); + this.targetWindows.add(T); + } + }]); + return VCDiff; +}(); +var Delta = /*#__PURE__*/function () { + function Delta(U, UTargetPosition, data, addresses) { + _classCallCheck(this, Delta); + this.U = U; + this.UTargetPosition = UTargetPosition; + this.data = data; + this.dataPosition = 0; + this.addresses = addresses; + this.addressesPosition = 0; + this.nearCache = new _near["default"](4); + this.sameCache = new _same["default"](3); + } + _createClass(Delta, [{ + key: "getNextAddressInteger", + value: function getNextAddressInteger() { + var value; + // get next address and increase the address position for the next address + var _deserializeInteger5 = (0, _integer["default"])(this.addresses, this.addressesPosition); + value = _deserializeInteger5.value; + this.addressesPosition = _deserializeInteger5.position; + return value; + } + }, { + key: "getNextAddressByte", + value: function getNextAddressByte() { + // get next address and increase the address position for the next address + var value = this.addresses[this.addressesPosition++]; + return value; + } + }]); + return Delta; +}(); + +/***/ }), +/* 47 */ +/***/ (function(module, exports, __webpack_require__) { + +var defineWellKnownSymbol = __webpack_require__(48); + +// `Symbol.iterator` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); + + +/***/ }), +/* 48 */ +/***/ (function(module, exports, __webpack_require__) { + +var path = __webpack_require__(36); +var has = __webpack_require__(16); +var wrappedWellKnownSymbolModule = __webpack_require__(49); +var defineProperty = __webpack_require__(20).f; + +module.exports = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, { + value: wrappedWellKnownSymbolModule.f(NAME) + }); +}; + + +/***/ }), +/* 49 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); + +exports.f = wellKnownSymbol; + + +/***/ }), +/* 50 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var shared = __webpack_require__(29); +var has = __webpack_require__(16); +var uid = __webpack_require__(31); +var NATIVE_SYMBOL = __webpack_require__(51); +var USE_SYMBOL_AS_UID = __webpack_require__(52); + +var WellKnownSymbolsStore = shared('wks'); +var Symbol = global.Symbol; +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; + +module.exports = function (name) { + if (!has(WellKnownSymbolsStore, name)) { + if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name]; + else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + + +/***/ }), +/* 51 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +module.exports = !!Object.getOwnPropertySymbols && !fails(function () { + // Chrome 38 Symbol has incorrect toString conversion + // eslint-disable-next-line no-undef + return !String(Symbol()); +}); + + +/***/ }), +/* 52 */ +/***/ (function(module, exports, __webpack_require__) { + +var NATIVE_SYMBOL = __webpack_require__(51); + +module.exports = NATIVE_SYMBOL + // eslint-disable-next-line no-undef + && !Symbol.sham + // eslint-disable-next-line no-undef + && typeof Symbol.iterator == 'symbol'; + + +/***/ }), +/* 53 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var charAt = __webpack_require__(54).charAt; +var InternalStateModule = __webpack_require__(26); +var defineIterator = __webpack_require__(55); + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = charAt(string, index); + state.index += point.length; + return { value: point, done: false }; +}); + + +/***/ }), +/* 54 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(41); +var requireObjectCoercible = __webpack_require__(13); + +// `String.prototype.{ codePointAt, at }` methods implementation +var createMethod = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = String(requireObjectCoercible($this)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = S.charCodeAt(position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING ? S.charAt(position) : first + : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +module.exports = { + // `String.prototype.codePointAt` method + // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod(true) +}; + + +/***/ }), +/* 55 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var createIteratorConstructor = __webpack_require__(56); +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var setToStringTag = __webpack_require__(65); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var wellKnownSymbol = __webpack_require__(50); +var IS_PURE = __webpack_require__(30); +var Iterators = __webpack_require__(66); +var IteratorsCore = __webpack_require__(57); + +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') { + createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; + } + } + + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return nativeIterator.call(this); }; + } + + // define iterator + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator); + } + Iterators[NAME] = defaultIterator; + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + return methods; +}; + + +/***/ }), +/* 56 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var IteratorPrototype = __webpack_require__(57).IteratorPrototype; +var create = __webpack_require__(61); +var createPropertyDescriptor = __webpack_require__(9); +var setToStringTag = __webpack_require__(65); +var Iterators = __webpack_require__(66); + +var returnThis = function () { return this; }; + +module.exports = function (IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; +}; + + +/***/ }), +/* 57 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getPrototypeOf = __webpack_require__(58); +var createNonEnumerableProperty = __webpack_require__(19); +var has = __webpack_require__(16); +var wellKnownSymbol = __webpack_require__(50); +var IS_PURE = __webpack_require__(30); + +var ITERATOR = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; + +var returnThis = function () { return this; }; + +// `%IteratorPrototype%` object +// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} + +if (IteratorPrototype == undefined) IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) { + createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis); +} + +module.exports = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + + +/***/ }), +/* 58 */ +/***/ (function(module, exports, __webpack_require__) { + +var has = __webpack_require__(16); +var toObject = __webpack_require__(59); +var sharedKey = __webpack_require__(28); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(60); + +var IE_PROTO = sharedKey('IE_PROTO'); +var ObjectPrototype = Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-object.getprototypeof +module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) { + O = toObject(O); + if (has(O, IE_PROTO)) return O[IE_PROTO]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } return O instanceof Object ? ObjectPrototype : null; +}; + + +/***/ }), +/* 59 */ +/***/ (function(module, exports, __webpack_require__) { + +var requireObjectCoercible = __webpack_require__(13); + +// `ToObject` abstract operation +// https://tc39.github.io/ecma262/#sec-toobject +module.exports = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + + +/***/ }), +/* 60 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + + +/***/ }), +/* 61 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var defineProperties = __webpack_require__(62); +var enumBugKeys = __webpack_require__(43); +var hiddenKeys = __webpack_require__(32); +var html = __webpack_require__(64); +var documentCreateElement = __webpack_require__(18); +var sharedKey = __webpack_require__(28); + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + /* global ActiveXObject */ + activeXDocument = document.domain && new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.github.io/ecma262/#sec-object.create +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : defineProperties(result, Properties); +}; + + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(20); +var anObject = __webpack_require__(21); +var objectKeys = __webpack_require__(63); + +// `Object.defineProperties` method +// https://tc39.github.io/ecma262/#sec-object.defineproperties +module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]); + return O; +}; + + +/***/ }), +/* 63 */ +/***/ (function(module, exports, __webpack_require__) { + +var internalObjectKeys = __webpack_require__(38); +var enumBugKeys = __webpack_require__(43); + +// `Object.keys` method +// https://tc39.github.io/ecma262/#sec-object.keys +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + + +/***/ }), +/* 64 */ +/***/ (function(module, exports, __webpack_require__) { + +var getBuiltIn = __webpack_require__(35); + +module.exports = getBuiltIn('document', 'documentElement'); + + +/***/ }), +/* 65 */ +/***/ (function(module, exports, __webpack_require__) { + +var defineProperty = __webpack_require__(20).f; +var has = __webpack_require__(16); +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +module.exports = function (it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + + +/***/ }), +/* 66 */ +/***/ (function(module, exports) { + +module.exports = {}; + + +/***/ }), +/* 67 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var aPossiblePrototype = __webpack_require__(68); + +// `Object.setPrototypeOf` method +// https://tc39.github.io/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +/* eslint-disable no-proto */ +module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; + setter.call(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter.call(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + + +/***/ }), +/* 68 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); + +module.exports = function (it) { + if (!isObject(it) && it !== null) { + throw TypeError("Can't set " + String(it) + ' as a prototype'); + } return it; +}; + + +/***/ }), +/* 69 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var DOMIterables = __webpack_require__(70); +var ArrayIteratorMethods = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(19); +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var ArrayValues = ArrayIteratorMethods.values; + +for (var COLLECTION_NAME in DOMIterables) { + var Collection = global[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + if (!CollectionPrototype[TO_STRING_TAG]) { + createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); + } + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +} + + +/***/ }), +/* 70 */ +/***/ (function(module, exports) { + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +module.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + + +/***/ }), +/* 71 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(10); +var addToUnscopables = __webpack_require__(72); +var Iterators = __webpack_require__(66); +var InternalStateModule = __webpack_require__(26); +var defineIterator = __webpack_require__(55); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.github.io/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.github.io/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.github.io/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.github.io/ecma262/#sec-createarrayiterator +module.exports = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { value: undefined, done: true }; + } + if (kind == 'keys') return { value: index, done: false }; + if (kind == 'values') return { value: target[index], done: false }; + return { value: [index, target[index]], done: false }; +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject +// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject +Iterators.Arguments = Iterators.Array; + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + + +/***/ }), +/* 72 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); +var create = __webpack_require__(61); +var definePropertyModule = __webpack_require__(20); + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] == undefined) { + definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + + +/***/ }), +/* 73 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var global = __webpack_require__(3); +var redefineAll = __webpack_require__(74); +var InternalMetadataModule = __webpack_require__(75); +var collection = __webpack_require__(77); +var collectionWeak = __webpack_require__(89); +var isObject = __webpack_require__(15); +var enforceIternalState = __webpack_require__(26).enforce; +var NATIVE_WEAK_MAP = __webpack_require__(27); + +var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; +var isExtensible = Object.isExtensible; +var InternalWeakMap; + +var wrapper = function (init) { + return function WeakMap() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}; + +// `WeakMap` constructor +// https://tc39.github.io/ecma262/#sec-weakmap-constructor +var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak); + +// IE11 WeakMap frozen keys fix +// We can't use feature detection because it crash some old IE builds +// https://github.com/zloirock/core-js/issues/485 +if (NATIVE_WEAK_MAP && IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + InternalMetadataModule.REQUIRED = true; + var WeakMapPrototype = $WeakMap.prototype; + var nativeDelete = WeakMapPrototype['delete']; + var nativeHas = WeakMapPrototype.has; + var nativeGet = WeakMapPrototype.get; + var nativeSet = WeakMapPrototype.set; + redefineAll(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeDelete.call(this, key) || state.frozen['delete'](key); + } return nativeDelete.call(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) || state.frozen.has(key); + } return nativeHas.call(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); + } return nativeGet.call(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); + } else nativeSet.call(this, key, value); + return this; + } + }); +} + + +/***/ }), +/* 74 */ +/***/ (function(module, exports, __webpack_require__) { + +var redefine = __webpack_require__(22); + +module.exports = function (target, src, options) { + for (var key in src) redefine(target, key, src[key], options); + return target; +}; + + +/***/ }), +/* 75 */ +/***/ (function(module, exports, __webpack_require__) { + +var hiddenKeys = __webpack_require__(32); +var isObject = __webpack_require__(15); +var has = __webpack_require__(16); +var defineProperty = __webpack_require__(20).f; +var uid = __webpack_require__(31); +var FREEZING = __webpack_require__(76); + +var METADATA = uid('meta'); +var id = 0; + +var isExtensible = Object.isExtensible || function () { + return true; +}; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + ++id, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); + return it; +}; + +var meta = module.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + + +/***/ }), +/* 76 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + return Object.isExtensible(Object.preventExtensions({})); +}); + + +/***/ }), +/* 77 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var isForced = __webpack_require__(45); +var redefine = __webpack_require__(22); +var InternalMetadataModule = __webpack_require__(75); +var iterate = __webpack_require__(78); +var anInstance = __webpack_require__(86); +var isObject = __webpack_require__(15); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(87); +var setToStringTag = __webpack_require__(65); +var inheritIfRequired = __webpack_require__(88); + +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, + KEY == 'add' ? function add(value) { + nativeMethod.call(this, value === 0 ? 0 : value); + return this; + } : KEY == 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : function set(key, value) { + nativeMethod.call(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + // eslint-disable-next-line max-len + if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })))) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.REQUIRED = true; + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + 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 && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, forced: Constructor != NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + + +/***/ }), +/* 78 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var isArrayIteratorMethod = __webpack_require__(79); +var toLength = __webpack_require__(40); +var bind = __webpack_require__(80); +var getIteratorMethod = __webpack_require__(82); +var callWithSafeIterationClosing = __webpack_require__(85); + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) { + var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1); + var iterator, iterFn, index, length, result, next, step; + + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = toLength(iterable.length); length > index; index++) { + result = AS_ENTRIES + ? boundFunction(anObject(step = iterable[index])[0], step[1]) + : boundFunction(iterable[index]); + if (result && result instanceof Result) return result; + } return new Result(false); + } + iterator = iterFn.call(iterable); + } + + next = iterator.next; + while (!(step = next.call(iterator)).done) { + result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES); + if (typeof result == 'object' && result && result instanceof Result) return result; + } return new Result(false); +}; + +iterate.stop = function (result) { + return new Result(true, result); +}; + + +/***/ }), +/* 79 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); +var Iterators = __webpack_require__(66); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + + +/***/ }), +/* 80 */ +/***/ (function(module, exports, __webpack_require__) { + +var aFunction = __webpack_require__(81); + +// optional / simple context binding +module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 0: return function () { + return fn.call(that); + }; + 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); + }; +}; + + +/***/ }), +/* 81 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + if (typeof it != 'function') { + throw TypeError(String(it) + ' is not a function'); + } return it; +}; + + +/***/ }), +/* 82 */ +/***/ (function(module, exports, __webpack_require__) { + +var classof = __webpack_require__(83); +var Iterators = __webpack_require__(66); +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); + +module.exports = function (it) { + if (it != undefined) return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; +}; + + +/***/ }), +/* 83 */ +/***/ (function(module, exports, __webpack_require__) { + +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var classofRaw = __webpack_require__(12); +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; +}; + + +/***/ }), +/* 84 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; + +test[TO_STRING_TAG] = 'z'; + +module.exports = String(test) === '[object z]'; + + +/***/ }), +/* 85 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); + +// call something on iterator step with safe closing on error +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 (error) { + var returnMethod = iterator['return']; + if (returnMethod !== undefined) anObject(returnMethod.call(iterator)); + throw error; + } +}; + + +/***/ }), +/* 86 */ +/***/ (function(module, exports) { + +module.exports = function (it, Constructor, name) { + if (!(it instanceof Constructor)) { + throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); + } return it; +}; + + +/***/ }), +/* 87 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line no-throw-literal + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +module.exports = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + + +/***/ }), +/* 88 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); +var setPrototypeOf = __webpack_require__(67); + +// makes subclassing work correct for wrapped built-ins +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + typeof (NewTarget = dummy.constructor) == 'function' && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + + +/***/ }), +/* 89 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var redefineAll = __webpack_require__(74); +var getWeakData = __webpack_require__(75).getWeakData; +var anObject = __webpack_require__(21); +var isObject = __webpack_require__(15); +var anInstance = __webpack_require__(86); +var iterate = __webpack_require__(78); +var ArrayIterationModule = __webpack_require__(90); +var $has = __webpack_require__(16); +var InternalStateModule = __webpack_require__(26); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (store) { + return store.frozen || (store.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) this.entries.splice(index, 1); + return !!~index; + } +}; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + }); + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + redefineAll(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && $has(data, state.id) && delete data[state.id]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && $has(data, state.id); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.3.3.3 WeakMap.prototype.get(key) + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // 23.3.3.5 WeakMap.prototype.set(key, value) + set: function set(key, value) { + return define(this, key, value); + } + } : { + // 23.4.3.1 WeakSet.prototype.add(value) + add: function add(value) { + return define(this, value, true); + } + }); + + return C; + } +}; + + +/***/ }), +/* 90 */ +/***/ (function(module, exports, __webpack_require__) { + +var bind = __webpack_require__(80); +var IndexedObject = __webpack_require__(11); +var toObject = __webpack_require__(59); +var toLength = __webpack_require__(40); +var arraySpeciesCreate = __webpack_require__(91); + +var push = [].push; + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push.call(target, value); // filter + } else if (IS_EVERY) return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +module.exports = { + // `Array.prototype.forEach` method + // https://tc39.github.io/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.github.io/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.github.io/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.github.io/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.github.io/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.github.io/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6) +}; + + +/***/ }), +/* 91 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); +var isArray = __webpack_require__(92); +var wellKnownSymbol = __webpack_require__(50); + +var SPECIES = wellKnownSymbol('species'); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.github.io/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray, length) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); +}; + + +/***/ }), +/* 92 */ +/***/ (function(module, exports, __webpack_require__) { + +var classof = __webpack_require__(12); + +// `IsArray` abstract operation +// https://tc39.github.io/ecma262/#sec-isarray +module.exports = Array.isArray || function isArray(arg) { + return classof(arg) == 'Array'; +}; + + +/***/ }), +/* 93 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var fails = __webpack_require__(7); +var toIndexedObject = __webpack_require__(10); +var nativeGetOwnPropertyDescriptor = __webpack_require__(5).f; +var DESCRIPTORS = __webpack_require__(6); + +var FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); }); +var FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor +$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { + return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); + } +}); + + +/***/ }), +/* 94 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var $reduce = __webpack_require__(95).left; +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); + +var STRICT_METHOD = arrayMethodIsStrict('reduce'); +var USES_TO_LENGTH = arrayMethodUsesToLength('reduce', { 1: 0 }); + +// `Array.prototype.reduce` method +// https://tc39.github.io/ecma262/#sec-array.prototype.reduce +$({ target: 'Array', proto: true, forced: !STRICT_METHOD || !USES_TO_LENGTH }, { + reduce: function reduce(callbackfn /* , initialValue */) { + return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 95 */ +/***/ (function(module, exports, __webpack_require__) { + +var aFunction = __webpack_require__(81); +var toObject = __webpack_require__(59); +var IndexedObject = __webpack_require__(11); +var toLength = __webpack_require__(40); + +// `Array.prototype.{ reduce, reduceRight }` methods implementation +var createMethod = function (IS_RIGHT) { + return function (that, callbackfn, argumentsLength, memo) { + aFunction(callbackfn); + var O = toObject(that); + var self = IndexedObject(O); + var length = toLength(O.length); + var index = IS_RIGHT ? length - 1 : 0; + var i = IS_RIGHT ? -1 : 1; + if (argumentsLength < 2) while (true) { + if (index in self) { + memo = self[index]; + index += i; + break; + } + index += i; + if (IS_RIGHT ? index < 0 : length <= index) { + throw TypeError('Reduce of empty array with no initial value'); + } + } + for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) { + memo = callbackfn(memo, self[index], index, O); + } + return memo; + }; +}; + +module.exports = { + // `Array.prototype.reduce` method + // https://tc39.github.io/ecma262/#sec-array.prototype.reduce + left: createMethod(false), + // `Array.prototype.reduceRight` method + // https://tc39.github.io/ecma262/#sec-array.prototype.reduceright + right: createMethod(true) +}; + + +/***/ }), +/* 96 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +module.exports = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function () { + // eslint-disable-next-line no-useless-call,no-throw-literal + method.call(null, argument || function () { throw 1; }, 1); + }); +}; + + +/***/ }), +/* 97 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var has = __webpack_require__(16); + +var defineProperty = Object.defineProperty; +var cache = {}; + +var thrower = function (it) { throw it; }; + +module.exports = function (METHOD_NAME, options) { + if (has(cache, METHOD_NAME)) return cache[METHOD_NAME]; + if (!options) options = {}; + var method = [][METHOD_NAME]; + var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false; + var argument0 = has(options, 0) ? options[0] : thrower; + var argument1 = has(options, 1) ? options[1] : undefined; + + return cache[METHOD_NAME] = !!method && !fails(function () { + if (ACCESSORS && !DESCRIPTORS) return true; + var O = { length: -1 }; + + if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower }); + else O[1] = 1; + + method.call(O, argument0, argument1); + }); +}; + + +/***/ }), +/* 98 */ +/***/ (function(module, exports, __webpack_require__) { + +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var redefine = __webpack_require__(22); +var toString = __webpack_require__(99); + +// `Object.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + redefine(Object.prototype, 'toString', toString, { unsafe: true }); +} + + +/***/ }), +/* 99 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var classof = __webpack_require__(83); + +// `Object.prototype.toString` method implementation +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + + +/***/ }), +/* 100 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var fails = __webpack_require__(7); +var ArrayBufferModule = __webpack_require__(101); +var anObject = __webpack_require__(21); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); +var speciesConstructor = __webpack_require__(106); + +var ArrayBuffer = ArrayBufferModule.ArrayBuffer; +var DataView = ArrayBufferModule.DataView; +var nativeArrayBufferSlice = ArrayBuffer.prototype.slice; + +var INCORRECT_SLICE = fails(function () { + return !new ArrayBuffer(2).slice(1, undefined).byteLength; +}); + +// `ArrayBuffer.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-arraybuffer.prototype.slice +$({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { + slice: function slice(start, end) { + if (nativeArrayBufferSlice !== undefined && end === undefined) { + return nativeArrayBufferSlice.call(anObject(this), start); // FF fix + } + var length = anObject(this).byteLength; + var first = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = new (speciesConstructor(this, ArrayBuffer))(toLength(fin - first)); + var viewSource = new DataView(this); + var viewTarget = new DataView(result); + var index = 0; + while (first < fin) { + viewTarget.setUint8(index++, viewSource.getUint8(first++)); + } return result; + } +}); + + +/***/ }), +/* 101 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var global = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_ARRAY_BUFFER = __webpack_require__(102); +var createNonEnumerableProperty = __webpack_require__(19); +var redefineAll = __webpack_require__(74); +var fails = __webpack_require__(7); +var anInstance = __webpack_require__(86); +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); +var toIndex = __webpack_require__(103); +var IEEE754 = __webpack_require__(104); +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var getOwnPropertyNames = __webpack_require__(37).f; +var defineProperty = __webpack_require__(20).f; +var arrayFill = __webpack_require__(105); +var setToStringTag = __webpack_require__(65); +var InternalStateModule = __webpack_require__(26); + +var getInternalState = InternalStateModule.get; +var setInternalState = InternalStateModule.set; +var ARRAY_BUFFER = 'ArrayBuffer'; +var DATA_VIEW = 'DataView'; +var PROTOTYPE = 'prototype'; +var WRONG_LENGTH = 'Wrong length'; +var WRONG_INDEX = 'Wrong index'; +var NativeArrayBuffer = global[ARRAY_BUFFER]; +var $ArrayBuffer = NativeArrayBuffer; +var $DataView = global[DATA_VIEW]; +var $DataViewPrototype = $DataView && $DataView[PROTOTYPE]; +var ObjectPrototype = Object.prototype; +var RangeError = global.RangeError; + +var packIEEE754 = IEEE754.pack; +var unpackIEEE754 = IEEE754.unpack; + +var packInt8 = function (number) { + return [number & 0xFF]; +}; + +var packInt16 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF]; +}; + +var packInt32 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF]; +}; + +var unpackInt32 = function (buffer) { + return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0]; +}; + +var packFloat32 = function (number) { + return packIEEE754(number, 23, 4); +}; + +var packFloat64 = function (number) { + return packIEEE754(number, 52, 8); +}; + +var addGetter = function (Constructor, key) { + defineProperty(Constructor[PROTOTYPE], key, { get: function () { return getInternalState(this)[key]; } }); +}; + +var get = function (view, count, index, isLittleEndian) { + var intIndex = toIndex(index); + var store = getInternalState(view); + if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); + var bytes = getInternalState(store.buffer).bytes; + var start = intIndex + store.byteOffset; + var pack = bytes.slice(start, start + count); + return isLittleEndian ? pack : pack.reverse(); +}; + +var set = function (view, count, index, conversion, value, isLittleEndian) { + var intIndex = toIndex(index); + var store = getInternalState(view); + if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX); + var bytes = getInternalState(store.buffer).bytes; + var start = intIndex + store.byteOffset; + var pack = conversion(+value); + for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1]; +}; + +if (!NATIVE_ARRAY_BUFFER) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer, ARRAY_BUFFER); + var byteLength = toIndex(length); + setInternalState(this, { + bytes: arrayFill.call(new Array(byteLength), 0), + byteLength: byteLength + }); + if (!DESCRIPTORS) this.byteLength = byteLength; + }; + + $DataView = function DataView(buffer, byteOffset, byteLength) { + anInstance(this, $DataView, DATA_VIEW); + anInstance(buffer, $ArrayBuffer, DATA_VIEW); + var bufferLength = getInternalState(buffer).byteLength; + var offset = toInteger(byteOffset); + if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset'); + byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength); + if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH); + setInternalState(this, { + buffer: buffer, + byteLength: byteLength, + byteOffset: offset + }); + if (!DESCRIPTORS) { + this.buffer = buffer; + this.byteLength = byteLength; + this.byteOffset = offset; + } + }; + + if (DESCRIPTORS) { + addGetter($ArrayBuffer, 'byteLength'); + addGetter($DataView, 'buffer'); + addGetter($DataView, 'byteLength'); + addGetter($DataView, 'byteOffset'); + } + + redefineAll($DataView[PROTOTYPE], { + getInt8: function getInt8(byteOffset) { + return get(this, 1, byteOffset)[0] << 24 >> 24; + }, + getUint8: function getUint8(byteOffset) { + return get(this, 1, byteOffset)[0]; + }, + getInt16: function getInt16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined); + return (bytes[1] << 8 | bytes[0]) << 16 >> 16; + }, + getUint16: function getUint16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined); + return bytes[1] << 8 | bytes[0]; + }, + getInt32: function getInt32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)); + }, + getUint32: function getUint32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)) >>> 0; + }, + getFloat32: function getFloat32(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 23); + }, + getFloat64: function getFloat64(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 52); + }, + setInt8: function setInt8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setUint8: function setUint8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setInt16: function setInt16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined); + }, + setUint16: function setUint16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined); + }, + setInt32: function setInt32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined); + }, + setUint32: function setUint32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined); + }, + setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : undefined); + }, + setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) { + set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : undefined); + } + }); +} else { + if (!fails(function () { + NativeArrayBuffer(1); + }) || !fails(function () { + new NativeArrayBuffer(-1); // eslint-disable-line no-new + }) || fails(function () { + new NativeArrayBuffer(); // eslint-disable-line no-new + new NativeArrayBuffer(1.5); // eslint-disable-line no-new + new NativeArrayBuffer(NaN); // eslint-disable-line no-new + return NativeArrayBuffer.name != ARRAY_BUFFER; + })) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, $ArrayBuffer); + return new NativeArrayBuffer(toIndex(length)); + }; + var ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE] = NativeArrayBuffer[PROTOTYPE]; + for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) { + if (!((key = keys[j++]) in $ArrayBuffer)) { + createNonEnumerableProperty($ArrayBuffer, key, NativeArrayBuffer[key]); + } + } + ArrayBufferPrototype.constructor = $ArrayBuffer; + } + + // WebKit bug - the same parent prototype for typed arrays and data view + if (setPrototypeOf && getPrototypeOf($DataViewPrototype) !== ObjectPrototype) { + setPrototypeOf($DataViewPrototype, ObjectPrototype); + } + + // iOS Safari 7.x bug + var testView = new $DataView(new $ArrayBuffer(2)); + var nativeSetInt8 = $DataViewPrototype.setInt8; + testView.setInt8(0, 2147483648); + testView.setInt8(1, 2147483649); + if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll($DataViewPrototype, { + setInt8: function setInt8(byteOffset, value) { + nativeSetInt8.call(this, byteOffset, value << 24 >> 24); + }, + setUint8: function setUint8(byteOffset, value) { + nativeSetInt8.call(this, byteOffset, value << 24 >> 24); + } + }, { unsafe: true }); +} + +setToStringTag($ArrayBuffer, ARRAY_BUFFER); +setToStringTag($DataView, DATA_VIEW); + +module.exports = { + ArrayBuffer: $ArrayBuffer, + DataView: $DataView +}; + + +/***/ }), +/* 102 */ +/***/ (function(module, exports) { + +module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined'; + + +/***/ }), +/* 103 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); + +// `ToIndex` abstract operation +// https://tc39.github.io/ecma262/#sec-toindex +module.exports = function (it) { + if (it === undefined) return 0; + var number = toInteger(it); + var length = toLength(number); + if (number !== length) throw RangeError('Wrong length or index'); + return length; +}; + + +/***/ }), +/* 104 */ +/***/ (function(module, exports) { + +// IEEE754 conversions based on https://github.com/feross/ieee754 +// eslint-disable-next-line no-shadow-restricted-names +var Infinity = 1 / 0; +var abs = Math.abs; +var pow = Math.pow; +var floor = Math.floor; +var log = Math.log; +var LN2 = Math.LN2; + +var pack = function (number, mantissaLength, bytes) { + var buffer = new Array(bytes); + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0; + var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0; + var index = 0; + var exponent, mantissa, c; + number = abs(number); + // eslint-disable-next-line no-self-compare + if (number != number || number === Infinity) { + // eslint-disable-next-line no-self-compare + mantissa = number != number ? 1 : 0; + exponent = eMax; + } else { + exponent = floor(log(number) / LN2); + if (number * (c = pow(2, -exponent)) < 1) { + exponent--; + c *= 2; + } + if (exponent + eBias >= 1) { + number += rt / c; + } else { + number += rt * pow(2, 1 - eBias); + } + if (number * c >= 2) { + exponent++; + c /= 2; + } + if (exponent + eBias >= eMax) { + mantissa = 0; + exponent = eMax; + } else if (exponent + eBias >= 1) { + mantissa = (number * c - 1) * pow(2, mantissaLength); + exponent = exponent + eBias; + } else { + mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength); + exponent = 0; + } + } + for (; mantissaLength >= 8; buffer[index++] = mantissa & 255, mantissa /= 256, mantissaLength -= 8); + exponent = exponent << mantissaLength | mantissa; + exponentLength += mantissaLength; + for (; exponentLength > 0; buffer[index++] = exponent & 255, exponent /= 256, exponentLength -= 8); + buffer[--index] |= sign * 128; + return buffer; +}; + +var unpack = function (buffer, mantissaLength) { + var bytes = buffer.length; + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var nBits = exponentLength - 7; + var index = bytes - 1; + var sign = buffer[index--]; + var exponent = sign & 127; + var mantissa; + sign >>= 7; + for (; nBits > 0; exponent = exponent * 256 + buffer[index], index--, nBits -= 8); + mantissa = exponent & (1 << -nBits) - 1; + exponent >>= -nBits; + nBits += mantissaLength; + for (; nBits > 0; mantissa = mantissa * 256 + buffer[index], index--, nBits -= 8); + if (exponent === 0) { + exponent = 1 - eBias; + } else if (exponent === eMax) { + return mantissa ? NaN : sign ? -Infinity : Infinity; + } else { + mantissa = mantissa + pow(2, mantissaLength); + exponent = exponent - eBias; + } return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength); +}; + +module.exports = { + pack: pack, + unpack: unpack +}; + + +/***/ }), +/* 105 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toObject = __webpack_require__(59); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); + +// `Array.prototype.fill` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.fill +module.exports = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = toLength(O.length); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + + +/***/ }), +/* 106 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var aFunction = __webpack_require__(81); +var wellKnownSymbol = __webpack_require__(50); + +var SPECIES = wellKnownSymbol('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.github.io/ecma262/#sec-speciesconstructor +module.exports = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S); +}; + + +/***/ }), +/* 107 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Uint8Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint8', function (init) { + return function Uint8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 108 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(109); +var ArrayBufferViewCore = __webpack_require__(110); +var ArrayBufferModule = __webpack_require__(101); +var anInstance = __webpack_require__(86); +var createPropertyDescriptor = __webpack_require__(9); +var createNonEnumerableProperty = __webpack_require__(19); +var toLength = __webpack_require__(40); +var toIndex = __webpack_require__(103); +var toOffset = __webpack_require__(111); +var toPrimitive = __webpack_require__(14); +var has = __webpack_require__(16); +var classof = __webpack_require__(83); +var isObject = __webpack_require__(15); +var create = __webpack_require__(61); +var setPrototypeOf = __webpack_require__(67); +var getOwnPropertyNames = __webpack_require__(37).f; +var typedArrayFrom = __webpack_require__(113); +var forEach = __webpack_require__(90).forEach; +var setSpecies = __webpack_require__(114); +var definePropertyModule = __webpack_require__(20); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var InternalStateModule = __webpack_require__(26); +var inheritIfRequired = __webpack_require__(88); + +var getInternalState = InternalStateModule.get; +var setInternalState = InternalStateModule.set; +var nativeDefineProperty = definePropertyModule.f; +var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; +var round = Math.round; +var RangeError = global.RangeError; +var ArrayBuffer = ArrayBufferModule.ArrayBuffer; +var DataView = ArrayBufferModule.DataView; +var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; +var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG; +var TypedArray = ArrayBufferViewCore.TypedArray; +var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype; +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var isTypedArray = ArrayBufferViewCore.isTypedArray; +var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; +var WRONG_LENGTH = 'Wrong length'; + +var fromList = function (C, list) { + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}; + +var addGetter = function (it, key) { + nativeDefineProperty(it, key, { get: function () { + return getInternalState(this)[key]; + } }); +}; + +var isArrayBuffer = function (it) { + var klass; + return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer'; +}; + +var isTypedArrayIndex = function (target, key) { + return isTypedArray(target) + && typeof key != 'symbol' + && key in target + && String(+key) == String(key); +}; + +var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) { + return isTypedArrayIndex(target, key = toPrimitive(key, true)) + ? createPropertyDescriptor(2, target[key]) + : nativeGetOwnPropertyDescriptor(target, key); +}; + +var wrappedDefineProperty = function defineProperty(target, key, descriptor) { + if (isTypedArrayIndex(target, key = toPrimitive(key, true)) + && isObject(descriptor) + && has(descriptor, 'value') + && !has(descriptor, 'get') + && !has(descriptor, 'set') + // TODO: add validation descriptor w/o calling accessors + && !descriptor.configurable + && (!has(descriptor, 'writable') || descriptor.writable) + && (!has(descriptor, 'enumerable') || descriptor.enumerable) + ) { + target[key] = descriptor.value; + return target; + } return nativeDefineProperty(target, key, descriptor); +}; + +if (DESCRIPTORS) { + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor; + definePropertyModule.f = wrappedDefineProperty; + addGetter(TypedArrayPrototype, 'buffer'); + addGetter(TypedArrayPrototype, 'byteOffset'); + addGetter(TypedArrayPrototype, 'byteLength'); + addGetter(TypedArrayPrototype, 'length'); + } + + $({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { + getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor, + defineProperty: wrappedDefineProperty + }); + + module.exports = function (TYPE, wrapper, CLAMPED) { + var BYTES = TYPE.match(/\d+$/)[0] / 8; + var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array'; + var GETTER = 'get' + TYPE; + var SETTER = 'set' + TYPE; + var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME]; + var TypedArrayConstructor = NativeTypedArrayConstructor; + var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype; + var exported = {}; + + var getter = function (that, index) { + var data = getInternalState(that); + return data.view[GETTER](index * BYTES + data.byteOffset, true); + }; + + var setter = function (that, index, value) { + var data = getInternalState(that); + if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF; + data.view[SETTER](index * BYTES + data.byteOffset, value, true); + }; + + var addElement = function (that, index) { + nativeDefineProperty(that, index, { + get: function () { + return getter(this, index); + }, + set: function (value) { + return setter(this, index, value); + }, + enumerable: true + }); + }; + + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + TypedArrayConstructor = wrapper(function (that, data, offset, $length) { + anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME); + var index = 0; + var byteOffset = 0; + var buffer, byteLength, length; + if (!isObject(data)) { + length = toIndex(data); + byteLength = length * BYTES; + buffer = new ArrayBuffer(byteLength); + } else if (isArrayBuffer(data)) { + buffer = data; + byteOffset = toOffset(offset, BYTES); + var $len = data.byteLength; + if ($length === undefined) { + if ($len % BYTES) throw RangeError(WRONG_LENGTH); + byteLength = $len - byteOffset; + if (byteLength < 0) throw RangeError(WRONG_LENGTH); + } else { + byteLength = toLength($length) * BYTES; + if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH); + } + length = byteLength / BYTES; + } else if (isTypedArray(data)) { + return fromList(TypedArrayConstructor, data); + } else { + return typedArrayFrom.call(TypedArrayConstructor, data); + } + setInternalState(that, { + buffer: buffer, + byteOffset: byteOffset, + byteLength: byteLength, + length: length, + view: new DataView(buffer) + }); + while (index < length) addElement(that, index++); + }); + + if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); + TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype); + } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) { + TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) { + anInstance(dummy, TypedArrayConstructor, CONSTRUCTOR_NAME); + return inheritIfRequired(function () { + if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data)); + if (isArrayBuffer(data)) return $length !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length) + : typedArrayOffset !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES)) + : new NativeTypedArrayConstructor(data); + if (isTypedArray(data)) return fromList(TypedArrayConstructor, data); + return typedArrayFrom.call(TypedArrayConstructor, data); + }(), dummy, TypedArrayConstructor); + }); + + if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); + forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) { + if (!(key in TypedArrayConstructor)) { + createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); + } + }); + TypedArrayConstructor.prototype = TypedArrayConstructorPrototype; + } + + if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); + } + + if (TYPED_ARRAY_TAG) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); + } + + exported[CONSTRUCTOR_NAME] = TypedArrayConstructor; + + $({ + global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS + }, exported); + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) { + createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); + } + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); + } + + setSpecies(CONSTRUCTOR_NAME); + }; +} else module.exports = function () { /* empty */ }; + + +/***/ }), +/* 109 */ +/***/ (function(module, exports, __webpack_require__) { + +/* eslint-disable no-new */ +var global = __webpack_require__(3); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(87); +var NATIVE_ARRAY_BUFFER_VIEWS = __webpack_require__(110).NATIVE_ARRAY_BUFFER_VIEWS; + +var ArrayBuffer = global.ArrayBuffer; +var Int8Array = global.Int8Array; + +module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () { + Int8Array(1); +}) || !fails(function () { + new Int8Array(-1); +}) || !checkCorrectnessOfIteration(function (iterable) { + new Int8Array(); + new Int8Array(null); + new Int8Array(1.5); + new Int8Array(iterable); +}, true) || fails(function () { + // Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill + return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1; +}); + + +/***/ }), +/* 110 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_ARRAY_BUFFER = __webpack_require__(102); +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); +var has = __webpack_require__(16); +var classof = __webpack_require__(83); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var defineProperty = __webpack_require__(20).f; +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var wellKnownSymbol = __webpack_require__(50); +var uid = __webpack_require__(31); + +var Int8Array = global.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var Uint8ClampedArray = global.Uint8ClampedArray; +var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; +var TypedArray = Int8Array && getPrototypeOf(Int8Array); +var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype); +var ObjectPrototype = Object.prototype; +var isPrototypeOf = ObjectPrototype.isPrototypeOf; + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); +// Fixing native typed arrays in Opera Presto crashes the browser, see #595 +var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera'; +var TYPED_ARRAY_TAG_REQIRED = false; +var NAME; + +var TypedArrayConstructorsList = { + Int8Array: 1, + Uint8Array: 1, + Uint8ClampedArray: 1, + Int16Array: 2, + Uint16Array: 2, + Int32Array: 4, + Uint32Array: 4, + Float32Array: 4, + Float64Array: 8 +}; + +var isView = function isView(it) { + var klass = classof(it); + return klass === 'DataView' || has(TypedArrayConstructorsList, klass); +}; + +var isTypedArray = function (it) { + return isObject(it) && has(TypedArrayConstructorsList, classof(it)); +}; + +var aTypedArray = function (it) { + if (isTypedArray(it)) return it; + throw TypeError('Target is not a typed array'); +}; + +var aTypedArrayConstructor = function (C) { + if (setPrototypeOf) { + if (isPrototypeOf.call(TypedArray, C)) return C; + } else for (var ARRAY in TypedArrayConstructorsList) if (has(TypedArrayConstructorsList, NAME)) { + var TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) { + return C; + } + } throw TypeError('Target is not a typed array constructor'); +}; + +var exportTypedArrayMethod = function (KEY, property, forced) { + if (!DESCRIPTORS) return; + if (forced) for (var ARRAY in TypedArrayConstructorsList) { + var TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) { + delete TypedArrayConstructor.prototype[KEY]; + } + } + if (!TypedArrayPrototype[KEY] || forced) { + redefine(TypedArrayPrototype, KEY, forced ? property + : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property); + } +}; + +var exportTypedArrayStaticMethod = function (KEY, property, forced) { + var ARRAY, TypedArrayConstructor; + if (!DESCRIPTORS) return; + if (setPrototypeOf) { + if (forced) for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) { + delete TypedArrayConstructor[KEY]; + } + } + if (!TypedArray[KEY] || forced) { + // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable + try { + return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property); + } catch (error) { /* empty */ } + } else return; + } + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = global[ARRAY]; + if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { + redefine(TypedArrayConstructor, KEY, property); + } + } +}; + +for (NAME in TypedArrayConstructorsList) { + if (!global[NAME]) NATIVE_ARRAY_BUFFER_VIEWS = false; +} + +// WebKit bug - typed arrays constructors prototype is Object.prototype +if (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) { + // eslint-disable-next-line no-shadow + TypedArray = function TypedArray() { + throw TypeError('Incorrect invocation'); + }; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (global[NAME]) setPrototypeOf(global[NAME], TypedArray); + } +} + +if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { + TypedArrayPrototype = TypedArray.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype); + } +} + +// WebKit bug - one more object in Uint8ClampedArray prototype chain +if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { + setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); +} + +if (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) { + TYPED_ARRAY_TAG_REQIRED = true; + defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () { + return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; + } }); + for (NAME in TypedArrayConstructorsList) if (global[NAME]) { + createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME); + } +} + +module.exports = { + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG, + aTypedArray: aTypedArray, + aTypedArrayConstructor: aTypedArrayConstructor, + exportTypedArrayMethod: exportTypedArrayMethod, + exportTypedArrayStaticMethod: exportTypedArrayStaticMethod, + isView: isView, + isTypedArray: isTypedArray, + TypedArray: TypedArray, + TypedArrayPrototype: TypedArrayPrototype +}; + + +/***/ }), +/* 111 */ +/***/ (function(module, exports, __webpack_require__) { + +var toPositiveInteger = __webpack_require__(112); + +module.exports = function (it, BYTES) { + var offset = toPositiveInteger(it); + if (offset % BYTES) throw RangeError('Wrong offset'); + return offset; +}; + + +/***/ }), +/* 112 */ +/***/ (function(module, exports, __webpack_require__) { + +var toInteger = __webpack_require__(41); + +module.exports = function (it) { + var result = toInteger(it); + if (result < 0) throw RangeError("The argument can't be less than 0"); + return result; +}; + + +/***/ }), +/* 113 */ +/***/ (function(module, exports, __webpack_require__) { + +var toObject = __webpack_require__(59); +var toLength = __webpack_require__(40); +var getIteratorMethod = __webpack_require__(82); +var isArrayIteratorMethod = __webpack_require__(79); +var bind = __webpack_require__(80); +var aTypedArrayConstructor = __webpack_require__(110).aTypedArrayConstructor; + +module.exports = function from(source /* , mapfn, thisArg */) { + var O = toObject(source); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var iteratorMethod = getIteratorMethod(O); + var i, length, result, step, iterator, next; + if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) { + iterator = iteratorMethod.call(O); + next = iterator.next; + O = []; + while (!(step = next.call(iterator)).done) { + O.push(step.value); + } + } + if (mapping && argumentsLength > 2) { + mapfn = bind(mapfn, arguments[2], 2); + } + length = toLength(O.length); + result = new (aTypedArrayConstructor(this))(length); + for (i = 0; length > i; i++) { + result[i] = mapping ? mapfn(O[i], i) : O[i]; + } + return result; +}; + + +/***/ }), +/* 114 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(35); +var definePropertyModule = __webpack_require__(20); +var wellKnownSymbol = __webpack_require__(50); +var DESCRIPTORS = __webpack_require__(6); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = definePropertyModule.f; + + if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { + defineProperty(Constructor, SPECIES, { + configurable: true, + get: function () { return this; } + }); + } +}; + + +/***/ }), +/* 115 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $copyWithin = __webpack_require__(116); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.copyWithin` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.copywithin +exportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end */) { + return $copyWithin.call(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined); +}); + + +/***/ }), +/* 116 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toObject = __webpack_require__(59); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); + +var min = Math.min; + +// `Array.prototype.copyWithin` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.copywithin +module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { + var O = toObject(this); + var len = toLength(O.length); + var to = toAbsoluteIndex(target, len); + var from = toAbsoluteIndex(start, len); + var end = arguments.length > 2 ? arguments[2] : undefined; + var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); + var 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; +}; + + +/***/ }), +/* 117 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $every = __webpack_require__(90).every; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.every` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.every +exportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) { + return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 118 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $fill = __webpack_require__(105); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.fill` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill +// eslint-disable-next-line no-unused-vars +exportTypedArrayMethod('fill', function fill(value /* , start, end */) { + return $fill.apply(aTypedArray(this), arguments); +}); + + +/***/ }), +/* 119 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $filter = __webpack_require__(90).filter; +var speciesConstructor = __webpack_require__(106); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.filter` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.filter +exportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) { + var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var C = speciesConstructor(this, this.constructor); + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}); + + +/***/ }), +/* 120 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $find = __webpack_require__(90).find; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.find` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.find +exportTypedArrayMethod('find', function find(predicate /* , thisArg */) { + return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 121 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $findIndex = __webpack_require__(90).findIndex; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.findIndex` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.findindex +exportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */) { + return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 122 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $forEach = __webpack_require__(90).forEach; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.forEach` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.foreach +exportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) { + $forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 123 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $includes = __webpack_require__(39).includes; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.includes` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.includes +exportTypedArrayMethod('includes', function includes(searchElement /* , fromIndex */) { + return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 124 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $indexOf = __webpack_require__(39).indexOf; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.indexOf` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.indexof +exportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex */) { + return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 125 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var global = __webpack_require__(3); +var ArrayBufferViewCore = __webpack_require__(110); +var ArrayIterators = __webpack_require__(71); +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); +var Uint8Array = global.Uint8Array; +var arrayValues = ArrayIterators.values; +var arrayKeys = ArrayIterators.keys; +var arrayEntries = ArrayIterators.entries; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var nativeTypedArrayIterator = Uint8Array && Uint8Array.prototype[ITERATOR]; + +var CORRECT_ITER_NAME = !!nativeTypedArrayIterator + && (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined); + +var typedArrayValues = function values() { + return arrayValues.call(aTypedArray(this)); +}; + +// `%TypedArray%.prototype.entries` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.entries +exportTypedArrayMethod('entries', function entries() { + return arrayEntries.call(aTypedArray(this)); +}); +// `%TypedArray%.prototype.keys` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.keys +exportTypedArrayMethod('keys', function keys() { + return arrayKeys.call(aTypedArray(this)); +}); +// `%TypedArray%.prototype.values` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.values +exportTypedArrayMethod('values', typedArrayValues, !CORRECT_ITER_NAME); +// `%TypedArray%.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype-@@iterator +exportTypedArrayMethod(ITERATOR, typedArrayValues, !CORRECT_ITER_NAME); + + +/***/ }), +/* 126 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $join = [].join; + +// `%TypedArray%.prototype.join` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join +// eslint-disable-next-line no-unused-vars +exportTypedArrayMethod('join', function join(separator) { + return $join.apply(aTypedArray(this), arguments); +}); + + +/***/ }), +/* 127 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $lastIndexOf = __webpack_require__(128); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.lastIndexOf` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.lastindexof +// eslint-disable-next-line no-unused-vars +exportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) { + return $lastIndexOf.apply(aTypedArray(this), arguments); +}); + + +/***/ }), +/* 128 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(10); +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); + +var min = Math.min; +var nativeLastIndexOf = [].lastIndexOf; +var NEGATIVE_ZERO = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; +var STRICT_METHOD = arrayMethodIsStrict('lastIndexOf'); +// For preventing possible almost infinite loop in non-standard implementations, test the forward version of the method +var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { ACCESSORS: true, 1: 0 }); +var FORCED = NEGATIVE_ZERO || !STRICT_METHOD || !USES_TO_LENGTH; + +// `Array.prototype.lastIndexOf` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof +module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + // convert -0 to +0 + if (NEGATIVE_ZERO) return nativeLastIndexOf.apply(this, arguments) || 0; + var O = toIndexedObject(this); + var length = toLength(O.length); + var index = length - 1; + if (arguments.length > 1) index = min(index, toInteger(arguments[1])); + if (index < 0) index = length + index; + for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0; + return -1; +} : nativeLastIndexOf; + + +/***/ }), +/* 129 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $map = __webpack_require__(90).map; +var speciesConstructor = __webpack_require__(106); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.map` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.map +exportTypedArrayMethod('map', function map(mapfn /* , thisArg */) { + return $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) { + return new (aTypedArrayConstructor(speciesConstructor(O, O.constructor)))(length); + }); +}); + + +/***/ }), +/* 130 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $reduce = __webpack_require__(95).left; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.reduce` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduce +exportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */) { + return $reduce(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 131 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $reduceRight = __webpack_require__(95).right; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.reduceRicht` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduceright +exportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initialValue */) { + return $reduceRight(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 132 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var floor = Math.floor; + +// `%TypedArray%.prototype.reverse` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reverse +exportTypedArrayMethod('reverse', function reverse() { + var that = this; + var length = aTypedArray(that).length; + var middle = floor(length / 2); + var index = 0; + var value; + while (index < middle) { + value = that[index]; + that[index++] = that[--length]; + that[length] = value; + } return that; +}); + + +/***/ }), +/* 133 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var toLength = __webpack_require__(40); +var toOffset = __webpack_require__(111); +var toObject = __webpack_require__(59); +var fails = __webpack_require__(7); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +var FORCED = fails(function () { + // eslint-disable-next-line no-undef + new Int8Array(1).set({}); +}); + +// `%TypedArray%.prototype.set` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.set +exportTypedArrayMethod('set', function set(arrayLike /* , offset */) { + aTypedArray(this); + var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1); + var length = this.length; + var src = toObject(arrayLike); + var len = toLength(src.length); + var index = 0; + if (len + offset > length) throw RangeError('Wrong length'); + while (index < len) this[offset + index] = src[index++]; +}, FORCED); + + +/***/ }), +/* 134 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var speciesConstructor = __webpack_require__(106); +var fails = __webpack_require__(7); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $slice = [].slice; + +var FORCED = fails(function () { + // eslint-disable-next-line no-undef + new Int8Array(1).slice(); +}); + +// `%TypedArray%.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice +exportTypedArrayMethod('slice', function slice(start, end) { + var list = $slice.call(aTypedArray(this), start, end); + var C = speciesConstructor(this, this.constructor); + var index = 0; + var length = list.length; + var result = new (aTypedArrayConstructor(C))(length); + while (length > index) result[index] = list[index++]; + return result; +}, FORCED); + + +/***/ }), +/* 135 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var $some = __webpack_require__(90).some; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.some` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.some +exportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) { + return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 136 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $sort = [].sort; + +// `%TypedArray%.prototype.sort` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort +exportTypedArrayMethod('sort', function sort(comparefn) { + return $sort.call(aTypedArray(this), comparefn); +}); + + +/***/ }), +/* 137 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(110); +var toLength = __webpack_require__(40); +var toAbsoluteIndex = __webpack_require__(42); +var speciesConstructor = __webpack_require__(106); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.subarray` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray +exportTypedArrayMethod('subarray', function subarray(begin, end) { + var O = aTypedArray(this); + var length = O.length; + var beginIndex = toAbsoluteIndex(begin, length); + return new (speciesConstructor(O, O.constructor))( + O.buffer, + O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, + toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) + ); +}); + + +/***/ }), +/* 138 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var global = __webpack_require__(3); +var ArrayBufferViewCore = __webpack_require__(110); +var fails = __webpack_require__(7); + +var Int8Array = global.Int8Array; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $toLocaleString = [].toLocaleString; +var $slice = [].slice; + +// iOS Safari 6.x fails here +var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () { + $toLocaleString.call(new Int8Array(1)); +}); + +var FORCED = fails(function () { + return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString(); +}) || !fails(function () { + Int8Array.prototype.toLocaleString.call([1, 2]); +}); + +// `%TypedArray%.prototype.toLocaleString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring +exportTypedArrayMethod('toLocaleString', function toLocaleString() { + return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments); +}, FORCED); + + +/***/ }), +/* 139 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var exportTypedArrayMethod = __webpack_require__(110).exportTypedArrayMethod; +var fails = __webpack_require__(7); +var global = __webpack_require__(3); + +var Uint8Array = global.Uint8Array; +var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {}; +var arrayToString = [].toString; +var arrayJoin = [].join; + +if (fails(function () { arrayToString.call({}); })) { + arrayToString = function toString() { + return arrayJoin.call(this); + }; +} + +var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString; + +// `%TypedArray%.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring +exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD); + + +/***/ }), +/* 140 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var isObject = __webpack_require__(15); +var isArray = __webpack_require__(92); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); +var toIndexedObject = __webpack_require__(10); +var createProperty = __webpack_require__(141); +var wellKnownSymbol = __webpack_require__(50); +var arrayMethodHasSpeciesSupport = __webpack_require__(142); +var arrayMethodUsesToLength = __webpack_require__(97); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice'); +var USES_TO_LENGTH = arrayMethodUsesToLength('slice', { ACCESSORS: true, 0: 0, 1: 2 }); + +var SPECIES = wellKnownSymbol('species'); +var nativeSlice = [].slice; +var max = Math.max; + +// `Array.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { + slice: function slice(start, end) { + var O = toIndexedObject(this); + var length = toLength(O.length); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject(Constructor)) { + Constructor = Constructor[SPECIES]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === Array || Constructor === undefined) { + return nativeSlice.call(O, k, fin); + } + } + result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + result.length = n; + return result; + } +}); + + +/***/ }), +/* 141 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toPrimitive = __webpack_require__(14); +var definePropertyModule = __webpack_require__(20); +var createPropertyDescriptor = __webpack_require__(9); + +module.exports = function (object, key, value) { + var propertyKey = toPrimitive(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + + +/***/ }), +/* 142 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(50); +var V8_VERSION = __webpack_require__(143); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + + +/***/ }), +/* 143 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var userAgent = __webpack_require__(144); + +var process = global.process; +var versions = process && process.versions; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + version = match[0] + match[1]; +} else if (userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) version = match[1]; + } +} + +module.exports = version && +version; + + +/***/ }), +/* 144 */ +/***/ (function(module, exports, __webpack_require__) { + +var getBuiltIn = __webpack_require__(35); + +module.exports = getBuiltIn('navigator', 'userAgent') || ''; + + +/***/ }), +/* 145 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var forEach = __webpack_require__(146); + +// `Array.prototype.forEach` method +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +$({ target: 'Array', proto: true, forced: [].forEach != forEach }, { + forEach: forEach +}); + + +/***/ }), +/* 146 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $forEach = __webpack_require__(90).forEach; +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); + +var STRICT_METHOD = arrayMethodIsStrict('forEach'); +var USES_TO_LENGTH = arrayMethodUsesToLength('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +module.exports = (!STRICT_METHOD || !USES_TO_LENGTH) ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +} : [].forEach; + + +/***/ }), +/* 147 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var DOMIterables = __webpack_require__(70); +var forEach = __webpack_require__(146); +var createNonEnumerableProperty = __webpack_require__(19); + +for (var COLLECTION_NAME in DOMIterables) { + var Collection = global[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +} + + +/***/ }), +/* 148 */ +/***/ (function(module, exports, __webpack_require__) { + +var defineWellKnownSymbol = __webpack_require__(48); + +// `Symbol.toPrimitive` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.toprimitive +defineWellKnownSymbol('toPrimitive'); + + +/***/ }), +/* 149 */ +/***/ (function(module, exports, __webpack_require__) { + +var createNonEnumerableProperty = __webpack_require__(19); +var dateToPrimitive = __webpack_require__(150); +var wellKnownSymbol = __webpack_require__(50); + +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var DatePrototype = Date.prototype; + +// `Date.prototype[@@toPrimitive]` method +// https://tc39.github.io/ecma262/#sec-date.prototype-@@toprimitive +if (!(TO_PRIMITIVE in DatePrototype)) { + createNonEnumerableProperty(DatePrototype, TO_PRIMITIVE, dateToPrimitive); +} + + +/***/ }), +/* 150 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(21); +var toPrimitive = __webpack_require__(14); + +module.exports = function (hint) { + if (hint !== 'string' && hint !== 'number' && hint !== 'default') { + throw TypeError('Incorrect hint'); + } return toPrimitive(anObject(this), hint !== 'number'); +}; + + +/***/ }), +/* 151 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var getBuiltIn = __webpack_require__(35); +var IS_PURE = __webpack_require__(30); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_SYMBOL = __webpack_require__(51); +var USE_SYMBOL_AS_UID = __webpack_require__(52); +var fails = __webpack_require__(7); +var has = __webpack_require__(16); +var isArray = __webpack_require__(92); +var isObject = __webpack_require__(15); +var anObject = __webpack_require__(21); +var toObject = __webpack_require__(59); +var toIndexedObject = __webpack_require__(10); +var toPrimitive = __webpack_require__(14); +var createPropertyDescriptor = __webpack_require__(9); +var nativeObjectCreate = __webpack_require__(61); +var objectKeys = __webpack_require__(63); +var getOwnPropertyNamesModule = __webpack_require__(37); +var getOwnPropertyNamesExternal = __webpack_require__(152); +var getOwnPropertySymbolsModule = __webpack_require__(44); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(20); +var propertyIsEnumerableModule = __webpack_require__(8); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var shared = __webpack_require__(29); +var sharedKey = __webpack_require__(28); +var hiddenKeys = __webpack_require__(32); +var uid = __webpack_require__(31); +var wellKnownSymbol = __webpack_require__(50); +var wrappedWellKnownSymbolModule = __webpack_require__(49); +var defineWellKnownSymbol = __webpack_require__(48); +var setToStringTag = __webpack_require__(65); +var InternalStateModule = __webpack_require__(26); +var $forEach = __webpack_require__(90).forEach; + +var HIDDEN = sharedKey('hidden'); +var SYMBOL = 'Symbol'; +var PROTOTYPE = 'prototype'; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(SYMBOL); +var ObjectPrototype = Object[PROTOTYPE]; +var $Symbol = global.Symbol; +var $stringify = getBuiltIn('JSON', 'stringify'); +var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; +var nativeDefineProperty = definePropertyModule.f; +var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f; +var nativePropertyIsEnumerable = propertyIsEnumerableModule.f; +var AllSymbols = shared('symbols'); +var ObjectPrototypeSymbols = shared('op-symbols'); +var StringToSymbolRegistry = shared('string-to-symbol-registry'); +var SymbolToStringRegistry = shared('symbol-to-string-registry'); +var WellKnownSymbolsStore = shared('wks'); +var QObject = global.QObject; +// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 +var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + +// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 +var setSymbolDescriptor = DESCRIPTORS && fails(function () { + return nativeObjectCreate(nativeDefineProperty({}, 'a', { + get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; } + })).a != 7; +}) ? function (O, P, Attributes) { + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P); + if (ObjectPrototypeDescriptor) delete ObjectPrototype[P]; + nativeDefineProperty(O, P, Attributes); + if (ObjectPrototypeDescriptor && O !== ObjectPrototype) { + nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor); + } +} : nativeDefineProperty; + +var wrap = function (tag, description) { + var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]); + setInternalState(symbol, { + type: SYMBOL, + tag: tag, + description: description + }); + if (!DESCRIPTORS) symbol.description = description; + return symbol; +}; + +var isSymbol = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + return Object(it) instanceof $Symbol; +}; + +var $defineProperty = function defineProperty(O, P, Attributes) { + if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes); + anObject(O); + var key = toPrimitive(P, true); + anObject(Attributes); + if (has(AllSymbols, key)) { + if (!Attributes.enumerable) { + if (!has(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {})); + O[HIDDEN][key] = true; + } else { + if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; + Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); + } return setSymbolDescriptor(O, key, Attributes); + } return nativeDefineProperty(O, key, Attributes); +}; + +var $defineProperties = function defineProperties(O, Properties) { + anObject(O); + var properties = toIndexedObject(Properties); + var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); + $forEach(keys, function (key) { + if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]); + }); + return O; +}; + +var $create = function create(O, Properties) { + return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties); +}; + +var $propertyIsEnumerable = function propertyIsEnumerable(V) { + var P = toPrimitive(V, true); + var enumerable = nativePropertyIsEnumerable.call(this, P); + if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false; + return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true; +}; + +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { + var it = toIndexedObject(O); + var key = toPrimitive(P, true); + if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return; + var descriptor = nativeGetOwnPropertyDescriptor(it, key); + if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) { + descriptor.enumerable = true; + } + return descriptor; +}; + +var $getOwnPropertyNames = function getOwnPropertyNames(O) { + var names = nativeGetOwnPropertyNames(toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key); + }); + return result; +}; + +var $getOwnPropertySymbols = function getOwnPropertySymbols(O) { + var IS_OBJECT_PROTOTYPE = O === ObjectPrototype; + var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) { + result.push(AllSymbols[key]); + } + }); + return result; +}; + +// `Symbol` constructor +// https://tc39.github.io/ecma262/#sec-symbol-constructor +if (!NATIVE_SYMBOL) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor'); + var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]); + var tag = uid(description); + var setter = function (value) { + if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); + }; + if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter }); + return wrap(tag, description); + }; + + redefine($Symbol[PROTOTYPE], 'toString', function toString() { + return getInternalState(this).tag; + }); + + redefine($Symbol, 'withoutSetter', function (description) { + return wrap(uid(description), description); + }); + + propertyIsEnumerableModule.f = $propertyIsEnumerable; + definePropertyModule.f = $defineProperty; + getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor; + getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames; + getOwnPropertySymbolsModule.f = $getOwnPropertySymbols; + + wrappedWellKnownSymbolModule.f = function (name) { + return wrap(wellKnownSymbol(name), name); + }; + + if (DESCRIPTORS) { + // https://github.com/tc39/proposal-Symbol-description + nativeDefineProperty($Symbol[PROTOTYPE], 'description', { + configurable: true, + get: function description() { + return getInternalState(this).description; + } + }); + if (!IS_PURE) { + redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + } + } +} + +$({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, { + Symbol: $Symbol +}); + +$forEach(objectKeys(WellKnownSymbolsStore), function (name) { + defineWellKnownSymbol(name); +}); + +$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, { + // `Symbol.for` method + // https://tc39.github.io/ecma262/#sec-symbol.for + 'for': function (key) { + var string = String(key); + if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; + var symbol = $Symbol(string); + StringToSymbolRegistry[string] = symbol; + SymbolToStringRegistry[symbol] = string; + return symbol; + }, + // `Symbol.keyFor` method + // https://tc39.github.io/ecma262/#sec-symbol.keyfor + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol'); + if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; + }, + useSetter: function () { USE_SETTER = true; }, + useSimple: function () { USE_SETTER = false; } +}); + +$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, { + // `Object.create` method + // https://tc39.github.io/ecma262/#sec-object.create + create: $create, + // `Object.defineProperty` method + // https://tc39.github.io/ecma262/#sec-object.defineproperty + defineProperty: $defineProperty, + // `Object.defineProperties` method + // https://tc39.github.io/ecma262/#sec-object.defineproperties + defineProperties: $defineProperties, + // `Object.getOwnPropertyDescriptor` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors + getOwnPropertyDescriptor: $getOwnPropertyDescriptor +}); + +$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, { + // `Object.getOwnPropertyNames` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertynames + getOwnPropertyNames: $getOwnPropertyNames, + // `Object.getOwnPropertySymbols` method + // https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols + getOwnPropertySymbols: $getOwnPropertySymbols +}); + +// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives +// https://bugs.chromium.org/p/v8/issues/detail?id=3443 +$({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + return getOwnPropertySymbolsModule.f(toObject(it)); + } +}); + +// `JSON.stringify` method behavior with symbols +// https://tc39.github.io/ecma262/#sec-json.stringify +if ($stringify) { + var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () { + var symbol = $Symbol(); + // MS Edge converts symbol values to JSON as {} + return $stringify([symbol]) != '[null]' + // WebKit converts symbol values to JSON as null + || $stringify({ a: symbol }) != '{}' + // V8 throws on boxed symbols + || $stringify(Object(symbol)) != '{}'; + }); + + $({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, { + // eslint-disable-next-line no-unused-vars + stringify: function stringify(it, replacer, space) { + var args = [it]; + var index = 1; + var $replacer; + while (arguments.length > index) args.push(arguments[index++]); + $replacer = replacer; + if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined + if (!isArray(replacer)) replacer = function (key, value) { + if (typeof $replacer == 'function') value = $replacer.call(this, key, value); + if (!isSymbol(value)) return value; + }; + args[1] = replacer; + return $stringify.apply(null, args); + } + }); +} + +// `Symbol.prototype[@@toPrimitive]` method +// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive +if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) { + createNonEnumerableProperty($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); +} +// `Symbol.prototype[@@toStringTag]` property +// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag +setToStringTag($Symbol, SYMBOL); + +hiddenKeys[HIDDEN] = true; + + +/***/ }), +/* 152 */ +/***/ (function(module, exports, __webpack_require__) { + +var toIndexedObject = __webpack_require__(10); +var nativeGetOwnPropertyNames = __webpack_require__(37).f; + +var toString = {}.toString; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return nativeGetOwnPropertyNames(it); + } catch (error) { + return windowNames.slice(); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +module.exports.f = function getOwnPropertyNames(it) { + return windowNames && toString.call(it) == '[object Window]' + ? getWindowNames(it) + : nativeGetOwnPropertyNames(toIndexedObject(it)); +}; + + +/***/ }), +/* 153 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// `Symbol.prototype.description` getter +// https://tc39.github.io/ecma262/#sec-symbol.prototype.description + +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var has = __webpack_require__(16); +var isObject = __webpack_require__(15); +var defineProperty = __webpack_require__(20).f; +var copyConstructorProperties = __webpack_require__(33); + +var NativeSymbol = global.Symbol; + +if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || + // Safari 12 bug + NativeSymbol().description !== undefined +)) { + var EmptyStringDescriptionStore = {}; + // wrap Symbol constructor for correct work with undefined description + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); + var result = this instanceof SymbolWrapper + ? new NativeSymbol(description) + // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' + : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') EmptyStringDescriptionStore[result] = true; + return result; + }; + copyConstructorProperties(SymbolWrapper, NativeSymbol); + var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; + symbolPrototype.constructor = SymbolWrapper; + + var symbolToString = symbolPrototype.toString; + var native = String(NativeSymbol('test')) == 'Symbol(test)'; + var regexp = /^Symbol\((.*)\)[^)]+$/; + defineProperty(symbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = isObject(this) ? this.valueOf() : this; + var string = symbolToString.call(symbol); + if (has(EmptyStringDescriptionStore, symbol)) return ''; + var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + + $({ global: true, forced: true }, { + Symbol: SymbolWrapper + }); +} + + +/***/ }), +/* 154 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var isForced = __webpack_require__(45); +var redefine = __webpack_require__(22); +var has = __webpack_require__(16); +var classof = __webpack_require__(12); +var inheritIfRequired = __webpack_require__(88); +var toPrimitive = __webpack_require__(14); +var fails = __webpack_require__(7); +var create = __webpack_require__(61); +var getOwnPropertyNames = __webpack_require__(37).f; +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var defineProperty = __webpack_require__(20).f; +var trim = __webpack_require__(155).trim; + +var NUMBER = 'Number'; +var NativeNumber = global[NUMBER]; +var NumberPrototype = NativeNumber.prototype; + +// Opera ~12 has broken Object#toString +var BROKEN_CLASSOF = classof(create(NumberPrototype)) == NUMBER; + +// `ToNumber` abstract operation +// https://tc39.github.io/ecma262/#sec-tonumber +var toNumber = function (argument) { + var it = toPrimitive(argument, false); + var first, third, radix, maxCode, digits, length, index, code; + if (typeof it == 'string' && it.length > 2) { + it = trim(it); + first = it.charCodeAt(0); + if (first === 43 || first === 45) { + third = it.charCodeAt(2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (it.charCodeAt(1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i + default: return +it; + } + digits = it.slice(2); + length = digits.length; + for (index = 0; index < length; index++) { + code = digits.charCodeAt(index); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; +}; + +// `Number` constructor +// https://tc39.github.io/ecma262/#sec-number-constructor +if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { + var NumberWrapper = function Number(value) { + var it = arguments.length < 1 ? 0 : value; + var dummy = this; + return dummy instanceof NumberWrapper + // check on 1..constructor(foo) case + && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classof(dummy) != NUMBER) + ? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it); + }; + for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger' + ).split(','), j = 0, key; keys.length > j; j++) { + if (has(NativeNumber, key = keys[j]) && !has(NumberWrapper, key)) { + defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key)); + } + } + NumberWrapper.prototype = NumberPrototype; + NumberPrototype.constructor = NumberWrapper; + redefine(global, NUMBER, NumberWrapper); +} + + +/***/ }), +/* 155 */ +/***/ (function(module, exports, __webpack_require__) { + +var requireObjectCoercible = __webpack_require__(13); +var whitespaces = __webpack_require__(156); + +var whitespace = '[' + whitespaces + ']'; +var ltrim = RegExp('^' + whitespace + whitespace + '*'); +var rtrim = RegExp(whitespace + whitespace + '*$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = String(requireObjectCoercible($this)); + if (TYPE & 1) string = string.replace(ltrim, ''); + if (TYPE & 2) string = string.replace(rtrim, ''); + return string; + }; +}; + +module.exports = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.github.io/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.github.io/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; + + +/***/ }), +/* 156 */ +/***/ (function(module, exports) { + +// a string of all valid unicode whitespaces +// eslint-disable-next-line max-len +module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + +/***/ }), +/* 157 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Takes in array of names of errors and returns an object mapping those names to error functions that take in one parameter that is used as the message for the error + * @param names {[]} + * @returns {{name1: function(message),...}} + * @constructor + */ +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(145); +__webpack_require__(98); +__webpack_require__(147); +__webpack_require__(158); +__webpack_require__(159); +function CustomErrors(names) { + var errors = {}; + names.forEach(function (name) { + var CustomError = function CustomError(message) { + var temp = Error.apply(this, arguments); + temp.name = this.name = name; + this.stack = temp.stack; + this.message = temp.message; + this.name = name; + this.message = message; + }; + CustomError.prototype = Object.create(Error.prototype, { + constructor: { + value: CustomError, + writable: true, + configurable: true + } + }); + errors[name] = CustomError; + }); + return errors; +} +var _default = exports["default"] = /* @__PURE__ */CustomErrors(['NotImplemented', 'InvalidDelta']); + +/***/ }), +/* 158 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var defineProperty = __webpack_require__(20).f; + +var FunctionPrototype = Function.prototype; +var FunctionPrototypeToString = FunctionPrototype.toString; +var nameRE = /^\s*function ([^ (]*)/; +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.github.io/ecma262/#sec-function-instances-name +if (DESCRIPTORS && !(NAME in FunctionPrototype)) { + defineProperty(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return FunctionPrototypeToString.call(this).match(nameRE)[1]; + } catch (error) { + return ''; + } + } + }); +} + + +/***/ }), +/* 159 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var create = __webpack_require__(61); + +// `Object.create` method +// https://tc39.github.io/ecma262/#sec-object.create +$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { + create: create +}); + + +/***/ }), +/* 160 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(154); +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TypedArrayList = void 0; +exports.equal = equal; +exports.stringToUint8Array = stringToUint8Array; +exports.uint8ArrayToString = uint8ArrayToString; +__webpack_require__(71); +__webpack_require__(100); +__webpack_require__(98); +__webpack_require__(107); +__webpack_require__(115); +__webpack_require__(117); +__webpack_require__(118); +__webpack_require__(119); +__webpack_require__(120); +__webpack_require__(121); +__webpack_require__(122); +__webpack_require__(123); +__webpack_require__(124); +__webpack_require__(125); +__webpack_require__(126); +__webpack_require__(127); +__webpack_require__(129); +__webpack_require__(130); +__webpack_require__(131); +__webpack_require__(132); +__webpack_require__(133); +__webpack_require__(134); +__webpack_require__(135); +__webpack_require__(136); +__webpack_require__(137); +__webpack_require__(138); +__webpack_require__(139); +__webpack_require__(161); +__webpack_require__(162); +__webpack_require__(163); +__webpack_require__(164); +__webpack_require__(165); +__webpack_require__(166); +__webpack_require__(167); +__webpack_require__(168); +__webpack_require__(169); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function uint8ArrayToString(uintArray) { + var encodedString = String.fromCharCode.apply(null, uintArray); + var decodedString = decodeURIComponent(escape(encodedString)); + return decodedString; +} +function stringToUint8Array(str) { + var buf = new Uint8Array(str.length); + for (var i = 0, strLen = str.length; i < strLen; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; +} +function equal(typedArray1, typedArray2) { + if (typedArray1.length !== typedArray2.length) { + return false; + } + for (var i = 0; i < typedArray1.length; i++) { + if (typedArray1[i] !== typedArray2[i]) { + return false; + } + } + return true; +} +var TypedArrayList = exports.TypedArrayList = /*#__PURE__*/function () { + function TypedArrayList() { + _classCallCheck(this, TypedArrayList); + this.typedArrays = []; + this.startIndexes = []; + this.length = 0; + } + _createClass(TypedArrayList, [{ + key: "add", + value: function add(typedArray) { + var typedArrayTypes = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; + var matchingTypedArrayTypes = typedArrayTypes.filter(function (typedArrayType) { + return typedArray instanceof typedArrayType; + }); + if (matchingTypedArrayTypes.length < 1) { + throw Error('Given ' + _typeof(typedArray) + ' when expected a TypedArray'); + } + var startIndex; + if (this.typedArrays.length === 0) { + startIndex = 0; + } else { + var lastIndex = this.startIndexes.length - 1; + var lastStartIndex = this.startIndexes[lastIndex]; + var lastLength = this.typedArrays[lastIndex].length; + startIndex = lastStartIndex + lastLength; + } + this.startIndexes.push(startIndex); + this.typedArrays.push(typedArray); + this.length += startIndex + typedArray.length; + } + }, { + key: "get", + value: function get(index) { + var listIndex = getIndex(this.startIndexes, index); + var typedArray = index - this.startIndexes[listIndex]; + return this.typedArrays[listIndex][typedArray]; + } + }, { + key: "set", + value: function set(index, value) { + if (typeof index !== 'number' || isNaN(index)) { + throw new Error('Given non-number index: ' + index); + } + //console.log(index); + + var listIndex = getIndex(this.startIndexes, index); + var typedArrayIndex = index - this.startIndexes[listIndex]; + this.typedArrays[listIndex][typedArrayIndex] = value; + } + }]); + return TypedArrayList; +}(); +function getIndex(arr, element) { + // Performance optimization for most common case + if (arr.length === 2) { + return element < arr[1] ? 0 : 1; + } + var low = 0; + var high = arr.length - 1; + while (low < high) { + var mid = Math.floor((low + high) / 2); + if (arr[mid] === element) { + return mid; + } else if (arr[mid] < element) { + low = mid + 1; + } else { + high = mid - 1; + } + } + if (arr[high] > element) { + return high - 1; + } else { + return high; + } +} + +/***/ }), +/* 161 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Int8Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int8', function (init) { + return function Int8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 162 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Uint8ClampedArray` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint8', function (init) { + return function Uint8ClampedArray(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}, true); + + +/***/ }), +/* 163 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Int16Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int16', function (init) { + return function Int16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 164 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Uint16Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint16', function (init) { + return function Uint16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 165 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Int32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int32', function (init) { + return function Int32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 166 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Uint32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint32', function (init) { + return function Uint32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 167 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Float32Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Float32', function (init) { + return function Float32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 168 */ +/***/ (function(module, exports, __webpack_require__) { + +var createTypedArrayConstructor = __webpack_require__(108); + +// `Float64Array` constructor +// https://tc39.github.io/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Float64', function (init) { + return function Float64Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 169 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var $filter = __webpack_require__(90).filter; +var arrayMethodHasSpeciesSupport = __webpack_require__(142); +var arrayMethodUsesToLength = __webpack_require__(97); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); +// Edge 14- issue +var USES_TO_LENGTH = arrayMethodUsesToLength('filter'); + +// `Array.prototype.filter` method +// https://tc39.github.io/ecma262/#sec-array.prototype.filter +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 170 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Converts RFC 3284 definition of integer in buffer to decimal + * Also returns the index of the byte after the integer + * @param buffer {Uint8Array} + * @param position {Number} + * @returns {{position: {Number}, value: {Number}}} + */ +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = integer; +function integer(buffer, position) { + var result = { + position: position, + value: 0 + }; + do { + /* Shift the existing value left for 7 bits (base127 conversion) + and merge it with the next value without its highest bit */ + result.value = result.value << 7 | buffer[result.position] & 127; + + /* Avoid Number overflows */ + if (result.value < 0) { + throw new Error('RFC 3284 Integer conversion: Buffer overflow'); + } + } while (buffer[result.position++] & 128); + return result; +} + +/***/ }), +/* 171 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = delta; +__webpack_require__(140); +var _errors = _interopRequireDefault(__webpack_require__(157)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var _tokenize_instructions = _interopRequireDefault(__webpack_require__(172)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function delta(delta, position) { + var targetWindowLength, dataLength, instructionsLength, addressesLength; + + // parentheses are needed for assignment destructuring + // Delta_Indicator byte + var _deserializeInteger = (0, _integer["default"])(delta, position); + targetWindowLength = _deserializeInteger.value; + position = _deserializeInteger.position; + if (delta[position] !== 0) { + throw new _errors["default"].NotImplemented('VCD_DECOMPRESS is not supported, Delta_Indicator must be zero at byte ' + position + ' and not ' + delta[position]); + } + position++; + var _deserializeInteger2 = (0, _integer["default"])(delta, position); + dataLength = _deserializeInteger2.value; + position = _deserializeInteger2.position; + var _deserializeInteger3 = (0, _integer["default"])(delta, position); + instructionsLength = _deserializeInteger3.value; + position = _deserializeInteger3.position; + var _deserializeInteger4 = (0, _integer["default"])(delta, position); + addressesLength = _deserializeInteger4.value; + position = _deserializeInteger4.position; + var dataNextPosition = position + dataLength; + var data = delta.slice(position, dataNextPosition); + var instructionsNextPosition = dataNextPosition + instructionsLength; + var instructions = delta.slice(dataNextPosition, instructionsNextPosition); + var deserializedInstructions = (0, _tokenize_instructions["default"])(instructions); + var addressesNextPosition = instructionsNextPosition + addressesLength; + var addresses = delta.slice(instructionsNextPosition, addressesNextPosition); + position = addressesNextPosition; + var window = { + targetWindowLength: targetWindowLength, + position: position, + data: data, + instructions: deserializedInstructions, + addresses: addresses + }; + return window; +} + +/***/ }), +/* 172 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = tokenizeInstructions; +var _instructions = _interopRequireDefault(__webpack_require__(173)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function tokenizeInstructions(instructionsBuffer) { + var deserializedInstructions = []; + var instructionsPosition = 0; + while (instructionsPosition < instructionsBuffer.length) { + var index = instructionsBuffer[instructionsPosition++]; + var addSize = void 0, + copySize = void 0, + size = void 0; + if (index === 0) { + var _deserializeInteger = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger.value; + instructionsPosition = _deserializeInteger.position; + deserializedInstructions.push(new _instructions["default"].RUN(size)); + } else if (index === 1) { + var _deserializeInteger2 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger2.value; + instructionsPosition = _deserializeInteger2.position; + deserializedInstructions.push(new _instructions["default"].ADD(size)); + } else if (index < 19) { + deserializedInstructions.push(new _instructions["default"].ADD(index - 1)); + } else if (index === 19) { + var _deserializeInteger3 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger3.value; + instructionsPosition = _deserializeInteger3.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 0)); + } else if (index < 35) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 16, 0)); + } else if (index === 35) { + var _deserializeInteger4 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger4.value; + instructionsPosition = _deserializeInteger4.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 1)); + } else if (index < 51) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 32, 1)); + } else if (index === 51) { + var _deserializeInteger5 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger5.value; + instructionsPosition = _deserializeInteger5.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 2)); + } else if (index < 67) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 48, 2)); + } else if (index === 67) { + var _deserializeInteger6 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger6.value; + instructionsPosition = _deserializeInteger6.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 3)); + } else if (index < 83) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 64, 3)); + } else if (index === 83) { + var _deserializeInteger7 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger7.value; + instructionsPosition = _deserializeInteger7.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 4)); + } else if (index < 99) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 80, 4)); + } else if (index === 99) { + var _deserializeInteger8 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger8.value; + instructionsPosition = _deserializeInteger8.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 5)); + } else if (index < 115) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 96, 5)); + } else if (index === 115) { + var _deserializeInteger9 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger9.value; + instructionsPosition = _deserializeInteger9.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 6)); + } else if (index < 131) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 112, 6)); + } else if (index === 131) { + var _deserializeInteger10 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger10.value; + instructionsPosition = _deserializeInteger10.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 7)); + } else if (index < 147) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 128, 7)); + } else if (index === 147) { + var _deserializeInteger11 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); + size = _deserializeInteger11.value; + instructionsPosition = _deserializeInteger11.position; + deserializedInstructions.push(new _instructions["default"].COPY(size, 8)); + } else if (index < 163) { + deserializedInstructions.push(new _instructions["default"].COPY(index - 144, 8)); + } else if (index < 175) { + var _ADD_COPY = ADD_COPY(index, 163); + addSize = _ADD_COPY.addSize; + copySize = _ADD_COPY.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 0)); + } else if (index < 187) { + var _ADD_COPY2 = ADD_COPY(index, 175); + addSize = _ADD_COPY2.addSize; + copySize = _ADD_COPY2.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 1)); + } else if (index < 199) { + var _ADD_COPY3 = ADD_COPY(index, 187); + addSize = _ADD_COPY3.addSize; + copySize = _ADD_COPY3.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 2)); + } else if (index < 211) { + var _ADD_COPY4 = ADD_COPY(index, 199); + addSize = _ADD_COPY4.addSize; + copySize = _ADD_COPY4.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 3)); + } else if (index < 223) { + var _ADD_COPY5 = ADD_COPY(index, 211); + addSize = _ADD_COPY5.addSize; + copySize = _ADD_COPY5.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 4)); + } else if (index < 235) { + var _ADD_COPY6 = ADD_COPY(index, 223); + addSize = _ADD_COPY6.addSize; + copySize = _ADD_COPY6.copySize; + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 5)); + } else if (index < 239) { + deserializedInstructions.push(new _instructions["default"].ADD(index - 235 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 6)); + } else if (index < 243) { + deserializedInstructions.push(new _instructions["default"].ADD(index - 239 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 7)); + } else if (index < 247) { + deserializedInstructions.push(new _instructions["default"].ADD(index - 243 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 8)); + } else if (index < 256) { + deserializedInstructions.push(new _instructions["default"].COPY(4, index - 247)); + deserializedInstructions.push(new _instructions["default"].ADD(1)); + } else { + throw new Error('Should not get here'); + } + } + return deserializedInstructions; +} +function ADD_COPY(index, baseIndex) { + var zeroBased = index - baseIndex; + + // 0,1,2 -> 0 3,4,5 -> 1 etc. + var addSizeIndex = Math.floor(zeroBased / 3); + // offset so size starts at 1 + var addSize = addSizeIndex + 1; + + // rotate through 0, 1, and 2 + var copySizeIndex = zeroBased % 3; + // offset so size starts at 4 + var copySize = copySizeIndex + 4; + return { + addSize: addSize, + copySize: copySize + }; +} + +/***/ }), +/* 173 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +__webpack_require__(73); +__webpack_require__(93); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var TypedArray = _interopRequireWildcard(__webpack_require__(160)); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var ADD = /*#__PURE__*/function () { + function ADD(size) { + _classCallCheck(this, ADD); + _defineProperty(this, "name", 'ADD'); + this.size = size; + } + _createClass(ADD, [{ + key: "execute", + value: function execute(delta) { + for (var i = 0; i < this.size; i++) { + delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition + i]); + } + delta.dataPosition += this.size; + delta.UTargetPosition += this.size; + } + }]); + return ADD; +}(); +var COPY = /*#__PURE__*/function () { + function COPY(size, mode) { + _classCallCheck(this, COPY); + _defineProperty(this, "name", 'COPY'); + this.size = size; + this.mode = mode; + } + _createClass(COPY, [{ + key: "execute", + value: function execute(delta) { + var address, m, next, method; + if (this.mode === 0) { + address = delta.getNextAddressInteger(); + } else if (this.mode === 1) { + next = delta.getNextAddressInteger(); + address = delta.UTargetPosition - next; + } else if ((m = this.mode - 2) >= 0 && m < delta.nearCache.size) { + next = delta.getNextAddressInteger(); + address = delta.nearCache.get(m, next); + method = 'near'; + } + // same cache + else { + m = this.mode - (2 + delta.nearCache.size); + next = delta.getNextAddressByte(); + address = delta.sameCache.get(m, next); + method = 'same'; + } + delta.nearCache.update(address); + delta.sameCache.update(address); + for (var i = 0; i < this.size; i++) { + delta.U.set(delta.UTargetPosition + i, delta.U.get(address + i)); + } + delta.UTargetPosition += this.size; + } + }]); + return COPY; +}(); +; +var RUN = /*#__PURE__*/function () { + function RUN(size) { + _classCallCheck(this, RUN); + _defineProperty(this, "name", 'RUN'); + this.size = size; + } + _createClass(RUN, [{ + key: "execute", + value: function execute(delta) { + for (var i = 0; i < this.size; i++) { + // repeat single byte + delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition]); + } + // increment to next byte + delta.dataPosition++; + delta.UTargetPosition += this.size; + } + }]); + return RUN; +}(); +var instructions = { + ADD: ADD, + COPY: COPY, + RUN: RUN +}; +var _default = exports["default"] = instructions; + +/***/ }), +/* 174 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(175); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var NearCache = exports["default"] = /*#__PURE__*/function () { + function NearCache(size) { + _classCallCheck(this, NearCache); + this.size = size; + this.near = new Array(this.size).fill(0); + this.nextSlot = 0; + } + _createClass(NearCache, [{ + key: "update", + value: function update(address) { + if (this.near.length > 0) { + this.near[this.nextSlot] = address; + this.nextSlot = (this.nextSlot + 1) % this.near.length; + } + } + }, { + key: "get", + value: function get(m, offset) { + var address = this.near[m] + offset; + return address; + } + }]); + return NearCache; +}(); + +/***/ }), +/* 175 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var fill = __webpack_require__(105); +var addToUnscopables = __webpack_require__(72); + +// `Array.prototype.fill` method +// https://tc39.github.io/ecma262/#sec-array.prototype.fill +$({ target: 'Array', proto: true }, { + fill: fill +}); + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('fill'); + + +/***/ }), +/* 176 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(175); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var SameCache = exports["default"] = /*#__PURE__*/function () { + function SameCache(size) { + _classCallCheck(this, SameCache); + this.size = size; + this.same = new Array(this.size * 256).fill(0); + } + _createClass(SameCache, [{ + key: "update", + value: function update(address) { + if (this.same.length > 0) { + this.same[address % (this.size * 256)] = address; + } + } + }, { + key: "get", + value: function get(m, offset) { + var address = this.same[m * 256 + offset]; + return address; + } + }]); + return SameCache; +}(); + +/***/ }) +/******/ ]))); \ No newline at end of file diff --git a/dist/vcdiff-decoder.js b/dist/vcdiff-decoder.js index df8c326..a789cc1 100644 --- a/dist/vcdiff-decoder.js +++ b/dist/vcdiff-decoder.js @@ -92,7 +92,13 @@ var vcdiffDecoder = "use strict"; -var VCDiff = __webpack_require__(1); +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.decode = decode; +var _vcdiff = _interopRequireDefault(__webpack_require__(46)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } /** * Vcdiff decode, applying delta to source and returning the result. * @@ -100,283 +106,37 @@ var VCDiff = __webpack_require__(1); * @param source {Uint8Array} The source to apply the delta diff/patch to. * @returns {Uint8Array} The result of applying delta to source. */ - - function decode(delta, source) { - var vcdiff = new VCDiff(delta, source); + var vcdiff = new _vcdiff["default"](delta, source); return vcdiff.decode(); } -module.exports = { - decode: decode -}; - /***/ }), /* 1 */ /***/ (function(module, exports, __webpack_require__) { -"use strict"; - - -__webpack_require__(2); - -__webpack_require__(59); - -__webpack_require__(74); - -__webpack_require__(76); - -__webpack_require__(81); - -__webpack_require__(90); - -__webpack_require__(94); - -__webpack_require__(106); - -__webpack_require__(108); - -__webpack_require__(109); - -__webpack_require__(110); - -__webpack_require__(111); - -__webpack_require__(112); - -__webpack_require__(113); - -__webpack_require__(114); - -__webpack_require__(115); - -__webpack_require__(116); - -__webpack_require__(117); - -__webpack_require__(118); - -__webpack_require__(120); - -__webpack_require__(121); - -__webpack_require__(122); - -__webpack_require__(123); - -__webpack_require__(124); - -__webpack_require__(125); - -__webpack_require__(126); - -__webpack_require__(127); - -__webpack_require__(128); - -__webpack_require__(129); - -__webpack_require__(130); - -__webpack_require__(131); - -var errors = __webpack_require__(133); - -var TypedArray = __webpack_require__(136); - -var deserializeInteger = __webpack_require__(155); - -var deserializeDelta = __webpack_require__(156); - -var NearCache = __webpack_require__(159); - -var SameCache = __webpack_require__(161); -/** - * - * @param delta {Uint8Array} - * @param source {Uint8Array} - * @constructor - */ - - -function VCDiff(delta, source) { - this.delta = delta; - this.position = 0; - this.source = source; - this.targetWindows = new TypedArray.TypedArrayList(); -} - -VCDiff.prototype.decode = function () { - this._consumeHeader(); - - while (this._consumeWindow()) {} - - var targetLength = this.targetWindows.typedArrays.reduce(function (sum, uint8Array) { - return uint8Array.length + sum; - }, 0); - var target = new Uint8Array(targetLength); - var position = 0; // concat all uint8arrays - - for (var arrayNum = 0; arrayNum < this.targetWindows.typedArrays.length; arrayNum++) { - var array = this.targetWindows.typedArrays[arrayNum]; - var length = array.length; - target.set(array, position); - position += length; - } - - return target; -}; - -VCDiff.prototype._consumeHeader = function () { - var hasVCDiffHeader = this.delta[0] === 214 && // V - this.delta[1] === 195 && // C - this.delta[2] === 196 && // D - this.delta[3] === 0; // \0 - - if (!hasVCDiffHeader) { - throw new errors.InvalidDelta('first 3 bytes not VCD'); - } - - var hdrIndicator = this.delta[4]; // extract least significant bit - - var vcdDecompress = 1 & hdrIndicator; // extract second least significant bit - - var vcdCodetable = 1 & hdrIndicator >> 1; // verify not using Hdr_Indicator - - if (vcdDecompress || vcdCodetable) { - throw new errors.NotImplemented('non-zero Hdr_Indicator (VCD_DECOMPRESS or VCD_CODETABLE bit is set)'); - } - - this.position += 5; -}; - -VCDiff.prototype._consumeWindow = function () { - var winIndicator = this.delta[this.position++]; // extract least significant bit - - var vcdSource = 1 & winIndicator; // extract second least significant bit - - var vcdTarget = 1 & winIndicator >> 1; - - if (vcdSource && vcdTarget) { - throw new errors.InvalidDelta('VCD_SOURCE and VCD_TARGET cannot both be set in Win_Indicator'); - } else if (vcdSource) { - var sourceSegmentLength, sourceSegmentPosition, deltaLength; - - var _deserializeInteger = deserializeInteger(this.delta, this.position); - - sourceSegmentLength = _deserializeInteger.value; - this.position = _deserializeInteger.position; - - var _deserializeInteger2 = deserializeInteger(this.delta, this.position); - - sourceSegmentPosition = _deserializeInteger2.value; - this.position = _deserializeInteger2.position; - - var _deserializeInteger3 = deserializeInteger(this.delta, this.position); - - deltaLength = _deserializeInteger3.value; - this.position = _deserializeInteger3.position; - var sourceSegment = this.source.slice(sourceSegmentPosition, sourceSegmentPosition + sourceSegmentLength); - - this._buildTargetWindow(this.position, sourceSegment); - - this.position += deltaLength; - } else if (vcdTarget) { - throw new errors.NotImplemented('non-zero VCD_TARGET in Win_Indicator'); - } else { - var _deltaLength; - - var _deserializeInteger4 = deserializeInteger(this.delta, this.position); - - _deltaLength = _deserializeInteger4.value; - this.position = _deserializeInteger4.position; - - this._buildTargetWindow(this.position); - - this.position += _deltaLength; - } - - return this.position < this.delta.length; -}; // first integer is target window length - - -VCDiff.prototype._buildTargetWindow = function (position, sourceSegment) { - var window = deserializeDelta(this.delta, position); - var T = new Uint8Array(window.targetWindowLength); - var U = new TypedArray.TypedArrayList(); - var uTargetPosition = 0; - - if (sourceSegment) { - U.add(sourceSegment); - uTargetPosition = sourceSegment.length; - } - - U.add(T); - var targetPosition = this.source.length; - var dataPosition = 0; - var delta = new Delta(U, uTargetPosition, window.data, window.addresses); - window.instructions.forEach(function (instruction) { - instruction.execute(delta); - }); - this.targetWindows.add(T); -}; - -function Delta(U, UTargetPosition, data, addresses) { - this.U = U; - this.UTargetPosition = UTargetPosition; - this.data = data; - this.dataPosition = 0; - this.addresses = addresses; - this.addressesPosition = 0; - this.nearCache = new NearCache(4); - this.sameCache = new SameCache(3); -} - -Delta.prototype.getNextAddressInteger = function () { - var value; // get next address and increase the address position for the next address - - var _deserializeInteger5 = deserializeInteger(this.addresses, this.addressesPosition); - - value = _deserializeInteger5.value; - this.addressesPosition = _deserializeInteger5.position; - return value; -}; - -Delta.prototype.getNextAddressByte = function () { - // get next address and increase the address position for the next address - var value = this.addresses[this.addressesPosition++]; - return value; -}; - -module.exports = VCDiff; - -/***/ }), -/* 2 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var $ = __webpack_require__(3); -var forEach = __webpack_require__(47); +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var objectDefinePropertyModile = __webpack_require__(20); -// `Array.prototype.forEach` method -// https://tc39.github.io/ecma262/#sec-array.prototype.foreach -$({ target: 'Array', proto: true, forced: [].forEach != forEach }, { - forEach: forEach +// `Object.defineProperty` method +// https://tc39.github.io/ecma262/#sec-object.defineproperty +$({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, { + defineProperty: objectDefinePropertyModile.f }); /***/ }), -/* 3 */ +/* 2 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var getOwnPropertyDescriptor = __webpack_require__(6).f; -var createNonEnumerableProperty = __webpack_require__(20); -var redefine = __webpack_require__(23); -var setGlobal = __webpack_require__(24); -var copyConstructorProperties = __webpack_require__(34); -var isForced = __webpack_require__(46); +var global = __webpack_require__(3); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var setGlobal = __webpack_require__(23); +var copyConstructorProperties = __webpack_require__(33); +var isForced = __webpack_require__(45); /* options.target - name of the target object @@ -427,7 +187,7 @@ module.exports = function (options, source) { /***/ }), -/* 4 */ +/* 3 */ /***/ (function(module, exports, __webpack_require__) { /* WEBPACK VAR INJECTION */(function(global) {var check = function (it) { @@ -444,10 +204,10 @@ module.exports = // eslint-disable-next-line no-new-func Function('return this')(); -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5))) +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(4))) /***/ }), -/* 5 */ +/* 4 */ /***/ (function(module, exports) { var g; @@ -473,16 +233,16 @@ module.exports = g; /***/ }), -/* 6 */ +/* 5 */ /***/ (function(module, exports, __webpack_require__) { -var DESCRIPTORS = __webpack_require__(7); -var propertyIsEnumerableModule = __webpack_require__(9); -var createPropertyDescriptor = __webpack_require__(10); -var toIndexedObject = __webpack_require__(11); -var toPrimitive = __webpack_require__(15); -var has = __webpack_require__(17); -var IE8_DOM_DEFINE = __webpack_require__(18); +var DESCRIPTORS = __webpack_require__(6); +var propertyIsEnumerableModule = __webpack_require__(8); +var createPropertyDescriptor = __webpack_require__(9); +var toIndexedObject = __webpack_require__(10); +var toPrimitive = __webpack_require__(14); +var has = __webpack_require__(16); +var IE8_DOM_DEFINE = __webpack_require__(17); var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; @@ -499,10 +259,10 @@ exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnProper /***/ }), -/* 7 */ +/* 6 */ /***/ (function(module, exports, __webpack_require__) { -var fails = __webpack_require__(8); +var fails = __webpack_require__(7); // Thank's IE8 for his funny defineProperty module.exports = !fails(function () { @@ -511,7 +271,7 @@ module.exports = !fails(function () { /***/ }), -/* 8 */ +/* 7 */ /***/ (function(module, exports) { module.exports = function (exec) { @@ -524,7 +284,7 @@ module.exports = function (exec) { /***/ }), -/* 9 */ +/* 8 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -544,7 +304,7 @@ exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { /***/ }), -/* 10 */ +/* 9 */ /***/ (function(module, exports) { module.exports = function (bitmap, value) { @@ -558,12 +318,12 @@ module.exports = function (bitmap, value) { /***/ }), -/* 11 */ +/* 10 */ /***/ (function(module, exports, __webpack_require__) { // toObject with fallback for non-array-like ES3 strings -var IndexedObject = __webpack_require__(12); -var requireObjectCoercible = __webpack_require__(14); +var IndexedObject = __webpack_require__(11); +var requireObjectCoercible = __webpack_require__(13); module.exports = function (it) { return IndexedObject(requireObjectCoercible(it)); @@ -571,11 +331,11 @@ module.exports = function (it) { /***/ }), -/* 12 */ +/* 11 */ /***/ (function(module, exports, __webpack_require__) { -var fails = __webpack_require__(8); -var classof = __webpack_require__(13); +var fails = __webpack_require__(7); +var classof = __webpack_require__(12); var split = ''.split; @@ -590,7 +350,7 @@ module.exports = fails(function () { /***/ }), -/* 13 */ +/* 12 */ /***/ (function(module, exports) { var toString = {}.toString; @@ -601,7 +361,7 @@ module.exports = function (it) { /***/ }), -/* 14 */ +/* 13 */ /***/ (function(module, exports) { // `RequireObjectCoercible` abstract operation @@ -613,10 +373,10 @@ module.exports = function (it) { /***/ }), -/* 15 */ +/* 14 */ /***/ (function(module, exports, __webpack_require__) { -var isObject = __webpack_require__(16); +var isObject = __webpack_require__(15); // `ToPrimitive` abstract operation // https://tc39.github.io/ecma262/#sec-toprimitive @@ -633,7 +393,7 @@ module.exports = function (input, PREFERRED_STRING) { /***/ }), -/* 16 */ +/* 15 */ /***/ (function(module, exports) { module.exports = function (it) { @@ -642,7 +402,7 @@ module.exports = function (it) { /***/ }), -/* 17 */ +/* 16 */ /***/ (function(module, exports) { var hasOwnProperty = {}.hasOwnProperty; @@ -653,12 +413,12 @@ module.exports = function (it, key) { /***/ }), -/* 18 */ +/* 17 */ /***/ (function(module, exports, __webpack_require__) { -var DESCRIPTORS = __webpack_require__(7); -var fails = __webpack_require__(8); -var createElement = __webpack_require__(19); +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var createElement = __webpack_require__(18); // Thank's IE8 for his funny defineProperty module.exports = !DESCRIPTORS && !fails(function () { @@ -669,11 +429,11 @@ module.exports = !DESCRIPTORS && !fails(function () { /***/ }), -/* 19 */ +/* 18 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var isObject = __webpack_require__(16); +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); var document = global.document; // typeof document.createElement is 'object' in old IE @@ -685,12 +445,12 @@ module.exports = function (it) { /***/ }), -/* 20 */ +/* 19 */ /***/ (function(module, exports, __webpack_require__) { -var DESCRIPTORS = __webpack_require__(7); -var definePropertyModule = __webpack_require__(21); -var createPropertyDescriptor = __webpack_require__(10); +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(20); +var createPropertyDescriptor = __webpack_require__(9); module.exports = DESCRIPTORS ? function (object, key, value) { return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); @@ -701,13 +461,13 @@ module.exports = DESCRIPTORS ? function (object, key, value) { /***/ }), -/* 21 */ +/* 20 */ /***/ (function(module, exports, __webpack_require__) { -var DESCRIPTORS = __webpack_require__(7); -var IE8_DOM_DEFINE = __webpack_require__(18); -var anObject = __webpack_require__(22); -var toPrimitive = __webpack_require__(15); +var DESCRIPTORS = __webpack_require__(6); +var IE8_DOM_DEFINE = __webpack_require__(17); +var anObject = __webpack_require__(21); +var toPrimitive = __webpack_require__(14); var nativeDefineProperty = Object.defineProperty; @@ -727,10 +487,10 @@ exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, A /***/ }), -/* 22 */ +/* 21 */ /***/ (function(module, exports, __webpack_require__) { -var isObject = __webpack_require__(16); +var isObject = __webpack_require__(15); module.exports = function (it) { if (!isObject(it)) { @@ -740,15 +500,15 @@ module.exports = function (it) { /***/ }), -/* 23 */ +/* 22 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var createNonEnumerableProperty = __webpack_require__(20); -var has = __webpack_require__(17); -var setGlobal = __webpack_require__(24); -var inspectSource = __webpack_require__(25); -var InternalStateModule = __webpack_require__(27); +var global = __webpack_require__(3); +var createNonEnumerableProperty = __webpack_require__(19); +var has = __webpack_require__(16); +var setGlobal = __webpack_require__(23); +var inspectSource = __webpack_require__(24); +var InternalStateModule = __webpack_require__(26); var getInternalState = InternalStateModule.get; var enforceInternalState = InternalStateModule.enforce; @@ -780,11 +540,11 @@ var TEMPLATE = String(String).split('String'); /***/ }), -/* 24 */ +/* 23 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var createNonEnumerableProperty = __webpack_require__(20); +var global = __webpack_require__(3); +var createNonEnumerableProperty = __webpack_require__(19); module.exports = function (key, value) { try { @@ -796,10 +556,10 @@ module.exports = function (key, value) { /***/ }), -/* 25 */ +/* 24 */ /***/ (function(module, exports, __webpack_require__) { -var store = __webpack_require__(26); +var store = __webpack_require__(25); var functionToString = Function.toString; @@ -814,11 +574,11 @@ module.exports = store.inspectSource; /***/ }), -/* 26 */ +/* 25 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var setGlobal = __webpack_require__(24); +var global = __webpack_require__(3); +var setGlobal = __webpack_require__(23); var SHARED = '__core-js_shared__'; var store = global[SHARED] || setGlobal(SHARED, {}); @@ -827,16 +587,16 @@ module.exports = store; /***/ }), -/* 27 */ +/* 26 */ /***/ (function(module, exports, __webpack_require__) { -var NATIVE_WEAK_MAP = __webpack_require__(28); -var global = __webpack_require__(4); -var isObject = __webpack_require__(16); -var createNonEnumerableProperty = __webpack_require__(20); -var objectHas = __webpack_require__(17); -var sharedKey = __webpack_require__(29); -var hiddenKeys = __webpack_require__(33); +var NATIVE_WEAK_MAP = __webpack_require__(27); +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); +var createNonEnumerableProperty = __webpack_require__(19); +var objectHas = __webpack_require__(16); +var sharedKey = __webpack_require__(28); +var hiddenKeys = __webpack_require__(32); var WeakMap = global.WeakMap; var set, get, has; @@ -894,11 +654,11 @@ module.exports = { /***/ }), -/* 28 */ +/* 27 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var inspectSource = __webpack_require__(25); +var global = __webpack_require__(3); +var inspectSource = __webpack_require__(24); var WeakMap = global.WeakMap; @@ -906,11 +666,11 @@ module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSour /***/ }), -/* 29 */ +/* 28 */ /***/ (function(module, exports, __webpack_require__) { -var shared = __webpack_require__(30); -var uid = __webpack_require__(32); +var shared = __webpack_require__(29); +var uid = __webpack_require__(31); var keys = shared('keys'); @@ -920,11 +680,11 @@ module.exports = function (key) { /***/ }), -/* 30 */ +/* 29 */ /***/ (function(module, exports, __webpack_require__) { -var IS_PURE = __webpack_require__(31); -var store = __webpack_require__(26); +var IS_PURE = __webpack_require__(30); +var store = __webpack_require__(25); (module.exports = function (key, value) { return store[key] || (store[key] = value !== undefined ? value : {}); @@ -936,14 +696,14 @@ var store = __webpack_require__(26); /***/ }), -/* 31 */ +/* 30 */ /***/ (function(module, exports) { module.exports = false; /***/ }), -/* 32 */ +/* 31 */ /***/ (function(module, exports) { var id = 0; @@ -955,20 +715,20 @@ module.exports = function (key) { /***/ }), -/* 33 */ +/* 32 */ /***/ (function(module, exports) { module.exports = {}; /***/ }), -/* 34 */ +/* 33 */ /***/ (function(module, exports, __webpack_require__) { -var has = __webpack_require__(17); -var ownKeys = __webpack_require__(35); -var getOwnPropertyDescriptorModule = __webpack_require__(6); -var definePropertyModule = __webpack_require__(21); +var has = __webpack_require__(16); +var ownKeys = __webpack_require__(34); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(20); module.exports = function (target, source) { var keys = ownKeys(source); @@ -982,13 +742,13 @@ module.exports = function (target, source) { /***/ }), -/* 35 */ +/* 34 */ /***/ (function(module, exports, __webpack_require__) { -var getBuiltIn = __webpack_require__(36); -var getOwnPropertyNamesModule = __webpack_require__(38); -var getOwnPropertySymbolsModule = __webpack_require__(45); -var anObject = __webpack_require__(22); +var getBuiltIn = __webpack_require__(35); +var getOwnPropertyNamesModule = __webpack_require__(37); +var getOwnPropertySymbolsModule = __webpack_require__(44); +var anObject = __webpack_require__(21); // all object keys, includes non-enumerable and symbols module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { @@ -999,11 +759,11 @@ module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { /***/ }), -/* 36 */ +/* 35 */ /***/ (function(module, exports, __webpack_require__) { -var path = __webpack_require__(37); -var global = __webpack_require__(4); +var path = __webpack_require__(36); +var global = __webpack_require__(3); var aFunction = function (variable) { return typeof variable == 'function' ? variable : undefined; @@ -1016,20 +776,20 @@ module.exports = function (namespace, method) { /***/ }), -/* 37 */ +/* 36 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); +var global = __webpack_require__(3); module.exports = global; /***/ }), -/* 38 */ +/* 37 */ /***/ (function(module, exports, __webpack_require__) { -var internalObjectKeys = __webpack_require__(39); -var enumBugKeys = __webpack_require__(44); +var internalObjectKeys = __webpack_require__(38); +var enumBugKeys = __webpack_require__(43); var hiddenKeys = enumBugKeys.concat('length', 'prototype'); @@ -1041,13 +801,13 @@ exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { /***/ }), -/* 39 */ +/* 38 */ /***/ (function(module, exports, __webpack_require__) { -var has = __webpack_require__(17); -var toIndexedObject = __webpack_require__(11); -var indexOf = __webpack_require__(40).indexOf; -var hiddenKeys = __webpack_require__(33); +var has = __webpack_require__(16); +var toIndexedObject = __webpack_require__(10); +var indexOf = __webpack_require__(39).indexOf; +var hiddenKeys = __webpack_require__(32); module.exports = function (object, names) { var O = toIndexedObject(object); @@ -1064,12 +824,12 @@ module.exports = function (object, names) { /***/ }), -/* 40 */ +/* 39 */ /***/ (function(module, exports, __webpack_require__) { -var toIndexedObject = __webpack_require__(11); -var toLength = __webpack_require__(41); -var toAbsoluteIndex = __webpack_require__(43); +var toIndexedObject = __webpack_require__(10); +var toLength = __webpack_require__(40); +var toAbsoluteIndex = __webpack_require__(42); // `Array.prototype.{ indexOf, includes }` methods implementation var createMethod = function (IS_INCLUDES) { @@ -1102,10 +862,10 @@ module.exports = { /***/ }), -/* 41 */ +/* 40 */ /***/ (function(module, exports, __webpack_require__) { -var toInteger = __webpack_require__(42); +var toInteger = __webpack_require__(41); var min = Math.min; @@ -1117,7 +877,7 @@ module.exports = function (argument) { /***/ }), -/* 42 */ +/* 41 */ /***/ (function(module, exports) { var ceil = Math.ceil; @@ -1131,10 +891,10 @@ module.exports = function (argument) { /***/ }), -/* 43 */ +/* 42 */ /***/ (function(module, exports, __webpack_require__) { -var toInteger = __webpack_require__(42); +var toInteger = __webpack_require__(41); var max = Math.max; var min = Math.min; @@ -1149,7 +909,7 @@ module.exports = function (index, length) { /***/ }), -/* 44 */ +/* 43 */ /***/ (function(module, exports) { // IE8- don't enum bug keys @@ -1165,17 +925,17 @@ module.exports = [ /***/ }), -/* 45 */ +/* 44 */ /***/ (function(module, exports) { exports.f = Object.getOwnPropertySymbols; /***/ }), -/* 46 */ +/* 45 */ /***/ (function(module, exports, __webpack_require__) { -var fails = __webpack_require__(8); +var fails = __webpack_require__(7); var replacement = /#|\.prototype\./; @@ -1199,199 +959,275 @@ module.exports = isForced; /***/ }), -/* 47 */ +/* 46 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $forEach = __webpack_require__(48).forEach; -var arrayMethodIsStrict = __webpack_require__(57); -var arrayMethodUsesToLength = __webpack_require__(58); - -var STRICT_METHOD = arrayMethodIsStrict('forEach'); -var USES_TO_LENGTH = arrayMethodUsesToLength('forEach'); - -// `Array.prototype.forEach` method implementation -// https://tc39.github.io/ecma262/#sec-array.prototype.foreach -module.exports = (!STRICT_METHOD || !USES_TO_LENGTH) ? function forEach(callbackfn /* , thisArg */) { - return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); -} : [].forEach; - - -/***/ }), -/* 48 */ -/***/ (function(module, exports, __webpack_require__) { - -var bind = __webpack_require__(49); -var IndexedObject = __webpack_require__(12); -var toObject = __webpack_require__(51); -var toLength = __webpack_require__(41); -var arraySpeciesCreate = __webpack_require__(52); - -var push = [].push; -// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation -var createMethod = function (TYPE) { - var IS_MAP = TYPE == 1; - var IS_FILTER = TYPE == 2; - var IS_SOME = TYPE == 3; - var IS_EVERY = TYPE == 4; - var IS_FIND_INDEX = TYPE == 6; - var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; - return function ($this, callbackfn, that, specificCreate) { - var O = toObject($this); - var self = IndexedObject(O); - var boundFunction = bind(callbackfn, that, 3); - var length = toLength(self.length); - var index = 0; - var create = specificCreate || arraySpeciesCreate; - var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; - var value, result; - for (;length > index; index++) if (NO_HOLES || index in self) { - value = self[index]; - result = boundFunction(value, index, O); - if (TYPE) { - if (IS_MAP) target[index] = result; // map - else if (result) switch (TYPE) { - case 3: return true; // some - case 5: return value; // find - case 6: return index; // findIndex - case 2: push.call(target, value); // filter - } else if (IS_EVERY) return false; // every +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(53); +__webpack_require__(69); +__webpack_require__(73); +__webpack_require__(93); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(94); +__webpack_require__(98); +__webpack_require__(71); +__webpack_require__(100); +__webpack_require__(107); +__webpack_require__(115); +__webpack_require__(117); +__webpack_require__(118); +__webpack_require__(119); +__webpack_require__(120); +__webpack_require__(121); +__webpack_require__(122); +__webpack_require__(123); +__webpack_require__(124); +__webpack_require__(125); +__webpack_require__(126); +__webpack_require__(127); +__webpack_require__(129); +__webpack_require__(130); +__webpack_require__(131); +__webpack_require__(132); +__webpack_require__(133); +__webpack_require__(134); +__webpack_require__(135); +__webpack_require__(136); +__webpack_require__(137); +__webpack_require__(138); +__webpack_require__(139); +__webpack_require__(140); +__webpack_require__(145); +__webpack_require__(147); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(154); +var _errors = _interopRequireDefault(__webpack_require__(157)); +var TypedArray = _interopRequireWildcard(__webpack_require__(160)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var _delta = _interopRequireDefault(__webpack_require__(171)); +var _near = _interopRequireDefault(__webpack_require__(174)); +var _same = _interopRequireDefault(__webpack_require__(176)); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +/** + * + * @param delta {Uint8Array} + * @param source {Uint8Array} + * @constructor + */ +var VCDiff = exports["default"] = /*#__PURE__*/function () { + function VCDiff(delta, source) { + _classCallCheck(this, VCDiff); + this.delta = delta; + this.position = 0; + this.source = source; + this.targetWindows = new TypedArray.TypedArrayList(); + } + _createClass(VCDiff, [{ + key: "decode", + value: function decode() { + this._consumeHeader(); + while (this._consumeWindow()) {} + var targetLength = this.targetWindows.typedArrays.reduce(function (sum, uint8Array) { + return uint8Array.length + sum; + }, 0); + var target = new Uint8Array(targetLength); + var position = 0; + + // concat all uint8arrays + for (var arrayNum = 0; arrayNum < this.targetWindows.typedArrays.length; arrayNum++) { + var array = this.targetWindows.typedArrays[arrayNum]; + var length = array.length; + target.set(array, position); + position += length; } + return target; } - return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; - }; -}; - -module.exports = { - // `Array.prototype.forEach` method - // https://tc39.github.io/ecma262/#sec-array.prototype.foreach - forEach: createMethod(0), - // `Array.prototype.map` method - // https://tc39.github.io/ecma262/#sec-array.prototype.map - map: createMethod(1), - // `Array.prototype.filter` method - // https://tc39.github.io/ecma262/#sec-array.prototype.filter - filter: createMethod(2), - // `Array.prototype.some` method - // https://tc39.github.io/ecma262/#sec-array.prototype.some - some: createMethod(3), - // `Array.prototype.every` method - // https://tc39.github.io/ecma262/#sec-array.prototype.every - every: createMethod(4), - // `Array.prototype.find` method - // https://tc39.github.io/ecma262/#sec-array.prototype.find - find: createMethod(5), - // `Array.prototype.findIndex` method - // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex - findIndex: createMethod(6) -}; - - -/***/ }), -/* 49 */ -/***/ (function(module, exports, __webpack_require__) { - -var aFunction = __webpack_require__(50); - -// optional / simple context binding -module.exports = function (fn, that, length) { - aFunction(fn); - if (that === undefined) return fn; - switch (length) { - case 0: return function () { - return fn.call(that); - }; - 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); - }; + }, { + key: "_consumeHeader", + value: function _consumeHeader() { + var hasVCDiffHeader = this.delta[0] === 214 && + // V + this.delta[1] === 195 && + // C + this.delta[2] === 196 && + // D + this.delta[3] === 0; // \0 + + if (!hasVCDiffHeader) { + throw new _errors["default"].InvalidDelta('first 3 bytes not VCD'); + } + var hdrIndicator = this.delta[4]; + // extract least significant bit + var vcdDecompress = 1 & hdrIndicator; + // extract second least significant bit + var vcdCodetable = 1 & hdrIndicator >> 1; + + // verify not using Hdr_Indicator + if (vcdDecompress || vcdCodetable) { + throw new _errors["default"].NotImplemented('non-zero Hdr_Indicator (VCD_DECOMPRESS or VCD_CODETABLE bit is set)'); + } + this.position += 5; + } + }, { + key: "_consumeWindow", + value: function _consumeWindow() { + var winIndicator = this.delta[this.position++]; + + // extract least significant bit + var vcdSource = 1 & winIndicator; + // extract second least significant bit + var vcdTarget = 1 & winIndicator >> 1; + if (vcdSource && vcdTarget) { + throw new _errors["default"].InvalidDelta('VCD_SOURCE and VCD_TARGET cannot both be set in Win_Indicator'); + } else if (vcdSource) { + var sourceSegmentLength, sourceSegmentPosition, deltaLength; + var _deserializeInteger = (0, _integer["default"])(this.delta, this.position); + sourceSegmentLength = _deserializeInteger.value; + this.position = _deserializeInteger.position; + var _deserializeInteger2 = (0, _integer["default"])(this.delta, this.position); + sourceSegmentPosition = _deserializeInteger2.value; + this.position = _deserializeInteger2.position; + var _deserializeInteger3 = (0, _integer["default"])(this.delta, this.position); + deltaLength = _deserializeInteger3.value; + this.position = _deserializeInteger3.position; + var sourceSegment = this.source.slice(sourceSegmentPosition, sourceSegmentPosition + sourceSegmentLength); + this._buildTargetWindow(this.position, sourceSegment); + this.position += deltaLength; + } else if (vcdTarget) { + throw new _errors["default"].NotImplemented('non-zero VCD_TARGET in Win_Indicator'); + } else { + var _deltaLength; + var _deserializeInteger4 = (0, _integer["default"])(this.delta, this.position); + _deltaLength = _deserializeInteger4.value; + this.position = _deserializeInteger4.position; + this._buildTargetWindow(this.position); + this.position += _deltaLength; + } + return this.position < this.delta.length; + } + }, { + key: "_buildTargetWindow", + value: + // first integer is target window length + function _buildTargetWindow(position, sourceSegment) { + var window = (0, _delta["default"])(this.delta, position); + var T = new Uint8Array(window.targetWindowLength); + var U = new TypedArray.TypedArrayList(); + var uTargetPosition = 0; + if (sourceSegment) { + U.add(sourceSegment); + uTargetPosition = sourceSegment.length; + } + U.add(T); + var targetPosition = this.source.length; + var dataPosition = 0; + var delta = new Delta(U, uTargetPosition, window.data, window.addresses); + window.instructions.forEach(function (instruction) { + instruction.execute(delta); + }); + this.targetWindows.add(T); + } + }]); + return VCDiff; +}(); +var Delta = /*#__PURE__*/function () { + function Delta(U, UTargetPosition, data, addresses) { + _classCallCheck(this, Delta); + this.U = U; + this.UTargetPosition = UTargetPosition; + this.data = data; + this.dataPosition = 0; + this.addresses = addresses; + this.addressesPosition = 0; + this.nearCache = new _near["default"](4); + this.sameCache = new _same["default"](3); } - return function (/* ...args */) { - return fn.apply(that, arguments); - }; -}; - - -/***/ }), -/* 50 */ -/***/ (function(module, exports) { - -module.exports = function (it) { - if (typeof it != 'function') { - throw TypeError(String(it) + ' is not a function'); - } return it; -}; - + _createClass(Delta, [{ + key: "getNextAddressInteger", + value: function getNextAddressInteger() { + var value; + // get next address and increase the address position for the next address + var _deserializeInteger5 = (0, _integer["default"])(this.addresses, this.addressesPosition); + value = _deserializeInteger5.value; + this.addressesPosition = _deserializeInteger5.position; + return value; + } + }, { + key: "getNextAddressByte", + value: function getNextAddressByte() { + // get next address and increase the address position for the next address + var value = this.addresses[this.addressesPosition++]; + return value; + } + }]); + return Delta; +}(); /***/ }), -/* 51 */ +/* 47 */ /***/ (function(module, exports, __webpack_require__) { -var requireObjectCoercible = __webpack_require__(14); +var defineWellKnownSymbol = __webpack_require__(48); -// `ToObject` abstract operation -// https://tc39.github.io/ecma262/#sec-toobject -module.exports = function (argument) { - return Object(requireObjectCoercible(argument)); -}; +// `Symbol.iterator` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); /***/ }), -/* 52 */ +/* 48 */ /***/ (function(module, exports, __webpack_require__) { -var isObject = __webpack_require__(16); -var isArray = __webpack_require__(53); -var wellKnownSymbol = __webpack_require__(54); - -var SPECIES = wellKnownSymbol('species'); +var path = __webpack_require__(36); +var has = __webpack_require__(16); +var wrappedWellKnownSymbolModule = __webpack_require__(49); +var defineProperty = __webpack_require__(20).f; -// `ArraySpeciesCreate` abstract operation -// https://tc39.github.io/ecma262/#sec-arrayspeciescreate -module.exports = function (originalArray, length) { - var C; - if (isArray(originalArray)) { - C = originalArray.constructor; - // cross-realm fallback - if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; - else if (isObject(C)) { - C = C[SPECIES]; - if (C === null) C = undefined; - } - } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); +module.exports = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, { + value: wrappedWellKnownSymbolModule.f(NAME) + }); }; /***/ }), -/* 53 */ +/* 49 */ /***/ (function(module, exports, __webpack_require__) { -var classof = __webpack_require__(13); +var wellKnownSymbol = __webpack_require__(50); -// `IsArray` abstract operation -// https://tc39.github.io/ecma262/#sec-isarray -module.exports = Array.isArray || function isArray(arg) { - return classof(arg) == 'Array'; -}; +exports.f = wellKnownSymbol; /***/ }), -/* 54 */ +/* 50 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var shared = __webpack_require__(30); -var has = __webpack_require__(17); -var uid = __webpack_require__(32); -var NATIVE_SYMBOL = __webpack_require__(55); -var USE_SYMBOL_AS_UID = __webpack_require__(56); +var global = __webpack_require__(3); +var shared = __webpack_require__(29); +var has = __webpack_require__(16); +var uid = __webpack_require__(31); +var NATIVE_SYMBOL = __webpack_require__(51); +var USE_SYMBOL_AS_UID = __webpack_require__(52); var WellKnownSymbolsStore = shared('wks'); var Symbol = global.Symbol; @@ -1406,10 +1242,10 @@ module.exports = function (name) { /***/ }), -/* 55 */ +/* 51 */ /***/ (function(module, exports, __webpack_require__) { -var fails = __webpack_require__(8); +var fails = __webpack_require__(7); module.exports = !!Object.getOwnPropertySymbols && !fails(function () { // Chrome 38 Symbol has incorrect toString conversion @@ -1419,10 +1255,10 @@ module.exports = !!Object.getOwnPropertySymbols && !fails(function () { /***/ }), -/* 56 */ +/* 52 */ /***/ (function(module, exports, __webpack_require__) { -var NATIVE_SYMBOL = __webpack_require__(55); +var NATIVE_SYMBOL = __webpack_require__(51); module.exports = NATIVE_SYMBOL // eslint-disable-next-line no-undef @@ -1432,301 +1268,98 @@ module.exports = NATIVE_SYMBOL /***/ }), -/* 57 */ +/* 53 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var fails = __webpack_require__(8); +var charAt = __webpack_require__(54).charAt; +var InternalStateModule = __webpack_require__(26); +var defineIterator = __webpack_require__(55); -module.exports = function (METHOD_NAME, argument) { - var method = [][METHOD_NAME]; - return !!method && fails(function () { - // eslint-disable-next-line no-useless-call,no-throw-literal - method.call(null, argument || function () { throw 1; }, 1); +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 }); -}; +// `%StringIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = charAt(string, index); + state.index += point.length; + return { value: point, done: false }; +}); /***/ }), -/* 58 */ +/* 54 */ /***/ (function(module, exports, __webpack_require__) { -var DESCRIPTORS = __webpack_require__(7); -var fails = __webpack_require__(8); -var has = __webpack_require__(17); - -var defineProperty = Object.defineProperty; -var cache = {}; - -var thrower = function (it) { throw it; }; - -module.exports = function (METHOD_NAME, options) { - if (has(cache, METHOD_NAME)) return cache[METHOD_NAME]; - if (!options) options = {}; - var method = [][METHOD_NAME]; - var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false; - var argument0 = has(options, 0) ? options[0] : thrower; - var argument1 = has(options, 1) ? options[1] : undefined; - - return cache[METHOD_NAME] = !!method && !fails(function () { - if (ACCESSORS && !DESCRIPTORS) return true; - var O = { length: -1 }; +var toInteger = __webpack_require__(41); +var requireObjectCoercible = __webpack_require__(13); - if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower }); - else O[1] = 1; +// `String.prototype.{ codePointAt, at }` methods implementation +var createMethod = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = String(requireObjectCoercible($this)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = S.charCodeAt(position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING ? S.charAt(position) : first + : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; - method.call(O, argument0, argument1); - }); +module.exports = { + // `String.prototype.codePointAt` method + // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod(true) }; /***/ }), -/* 59 */ +/* 55 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var toIndexedObject = __webpack_require__(11); -var addToUnscopables = __webpack_require__(60); -var Iterators = __webpack_require__(65); -var InternalStateModule = __webpack_require__(27); -var defineIterator = __webpack_require__(66); +var $ = __webpack_require__(2); +var createIteratorConstructor = __webpack_require__(56); +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var setToStringTag = __webpack_require__(65); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var wellKnownSymbol = __webpack_require__(50); +var IS_PURE = __webpack_require__(30); +var Iterators = __webpack_require__(66); +var IteratorsCore = __webpack_require__(57); -var ARRAY_ITERATOR = 'Array Iterator'; -var setInternalState = InternalStateModule.set; -var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); - -// `Array.prototype.entries` method -// https://tc39.github.io/ecma262/#sec-array.prototype.entries -// `Array.prototype.keys` method -// https://tc39.github.io/ecma262/#sec-array.prototype.keys -// `Array.prototype.values` method -// https://tc39.github.io/ecma262/#sec-array.prototype.values -// `Array.prototype[@@iterator]` method -// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator -// `CreateArrayIterator` internal method -// https://tc39.github.io/ecma262/#sec-createarrayiterator -module.exports = defineIterator(Array, 'Array', function (iterated, kind) { - setInternalState(this, { - type: ARRAY_ITERATOR, - target: toIndexedObject(iterated), // target - index: 0, // next index - kind: kind // kind - }); -// `%ArrayIteratorPrototype%.next` method -// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next -}, function () { - var state = getInternalState(this); - var target = state.target; - var kind = state.kind; - var index = state.index++; - if (!target || index >= target.length) { - state.target = undefined; - return { value: undefined, done: true }; - } - if (kind == 'keys') return { value: index, done: false }; - if (kind == 'values') return { value: target[index], done: false }; - return { value: [index, target[index]], done: false }; -}, 'values'); - -// argumentsList[@@iterator] is %ArrayProto_values% -// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject -// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject -Iterators.Arguments = Iterators.Array; - -// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables -addToUnscopables('keys'); -addToUnscopables('values'); -addToUnscopables('entries'); - - -/***/ }), -/* 60 */ -/***/ (function(module, exports, __webpack_require__) { - -var wellKnownSymbol = __webpack_require__(54); -var create = __webpack_require__(61); -var definePropertyModule = __webpack_require__(21); - -var UNSCOPABLES = wellKnownSymbol('unscopables'); -var ArrayPrototype = Array.prototype; - -// Array.prototype[@@unscopables] -// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables -if (ArrayPrototype[UNSCOPABLES] == undefined) { - definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { - configurable: true, - value: create(null) - }); -} - -// add a key to Array.prototype[@@unscopables] -module.exports = function (key) { - ArrayPrototype[UNSCOPABLES][key] = true; -}; - - -/***/ }), -/* 61 */ -/***/ (function(module, exports, __webpack_require__) { - -var anObject = __webpack_require__(22); -var defineProperties = __webpack_require__(62); -var enumBugKeys = __webpack_require__(44); -var hiddenKeys = __webpack_require__(33); -var html = __webpack_require__(64); -var documentCreateElement = __webpack_require__(19); -var sharedKey = __webpack_require__(29); - -var GT = '>'; -var LT = '<'; -var PROTOTYPE = 'prototype'; -var SCRIPT = 'script'; -var IE_PROTO = sharedKey('IE_PROTO'); - -var EmptyConstructor = function () { /* empty */ }; - -var scriptTag = function (content) { - return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; -}; - -// Create object with fake `null` prototype: use ActiveX Object with cleared prototype -var NullProtoObjectViaActiveX = function (activeXDocument) { - activeXDocument.write(scriptTag('')); - activeXDocument.close(); - var temp = activeXDocument.parentWindow.Object; - activeXDocument = null; // avoid memory leak - return temp; -}; - -// Create object with fake `null` prototype: use iframe Object with cleared prototype -var NullProtoObjectViaIFrame = function () { - // Thrash, waste and sodomy: IE GC bug - var iframe = documentCreateElement('iframe'); - var JS = 'java' + SCRIPT + ':'; - var iframeDocument; - iframe.style.display = 'none'; - html.appendChild(iframe); - // https://github.com/zloirock/core-js/issues/475 - iframe.src = String(JS); - iframeDocument = iframe.contentWindow.document; - iframeDocument.open(); - iframeDocument.write(scriptTag('document.F=Object')); - iframeDocument.close(); - return iframeDocument.F; -}; - -// Check for document.domain and active x support -// No need to use active x approach when document.domain is not set -// see https://github.com/es-shims/es5-shim/issues/150 -// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 -// avoid IE GC bug -var activeXDocument; -var NullProtoObject = function () { - try { - /* global ActiveXObject */ - activeXDocument = document.domain && new ActiveXObject('htmlfile'); - } catch (error) { /* ignore */ } - NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); - var length = enumBugKeys.length; - while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; - return NullProtoObject(); -}; - -hiddenKeys[IE_PROTO] = true; - -// `Object.create` method -// https://tc39.github.io/ecma262/#sec-object.create -module.exports = Object.create || function create(O, Properties) { - var result; - if (O !== null) { - EmptyConstructor[PROTOTYPE] = anObject(O); - result = new EmptyConstructor(); - EmptyConstructor[PROTOTYPE] = null; - // add "__proto__" for Object.getPrototypeOf polyfill - result[IE_PROTO] = O; - } else result = NullProtoObject(); - return Properties === undefined ? result : defineProperties(result, Properties); -}; - - -/***/ }), -/* 62 */ -/***/ (function(module, exports, __webpack_require__) { - -var DESCRIPTORS = __webpack_require__(7); -var definePropertyModule = __webpack_require__(21); -var anObject = __webpack_require__(22); -var objectKeys = __webpack_require__(63); - -// `Object.defineProperties` method -// https://tc39.github.io/ecma262/#sec-object.defineproperties -module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { - anObject(O); - var keys = objectKeys(Properties); - var length = keys.length; - var index = 0; - var key; - while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]); - return O; -}; - - -/***/ }), -/* 63 */ -/***/ (function(module, exports, __webpack_require__) { - -var internalObjectKeys = __webpack_require__(39); -var enumBugKeys = __webpack_require__(44); - -// `Object.keys` method -// https://tc39.github.io/ecma262/#sec-object.keys -module.exports = Object.keys || function keys(O) { - return internalObjectKeys(O, enumBugKeys); -}; - - -/***/ }), -/* 64 */ -/***/ (function(module, exports, __webpack_require__) { - -var getBuiltIn = __webpack_require__(36); - -module.exports = getBuiltIn('document', 'documentElement'); - - -/***/ }), -/* 65 */ -/***/ (function(module, exports) { - -module.exports = {}; - - -/***/ }), -/* 66 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var $ = __webpack_require__(3); -var createIteratorConstructor = __webpack_require__(67); -var getPrototypeOf = __webpack_require__(69); -var setPrototypeOf = __webpack_require__(72); -var setToStringTag = __webpack_require__(71); -var createNonEnumerableProperty = __webpack_require__(20); -var redefine = __webpack_require__(23); -var wellKnownSymbol = __webpack_require__(54); -var IS_PURE = __webpack_require__(31); -var Iterators = __webpack_require__(65); -var IteratorsCore = __webpack_require__(68); - -var IteratorPrototype = IteratorsCore.IteratorPrototype; -var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; -var ITERATOR = wellKnownSymbol('iterator'); -var KEYS = 'keys'; -var VALUES = 'values'; -var ENTRIES = 'entries'; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; var returnThis = function () { return this; }; @@ -1801,16 +1434,16 @@ module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, I /***/ }), -/* 67 */ +/* 56 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var IteratorPrototype = __webpack_require__(68).IteratorPrototype; +var IteratorPrototype = __webpack_require__(57).IteratorPrototype; var create = __webpack_require__(61); -var createPropertyDescriptor = __webpack_require__(10); -var setToStringTag = __webpack_require__(71); -var Iterators = __webpack_require__(65); +var createPropertyDescriptor = __webpack_require__(9); +var setToStringTag = __webpack_require__(65); +var Iterators = __webpack_require__(66); var returnThis = function () { return this; }; @@ -1824,16 +1457,16 @@ module.exports = function (IteratorConstructor, NAME, next) { /***/ }), -/* 68 */ +/* 57 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var getPrototypeOf = __webpack_require__(69); -var createNonEnumerableProperty = __webpack_require__(20); -var has = __webpack_require__(17); -var wellKnownSymbol = __webpack_require__(54); -var IS_PURE = __webpack_require__(31); +var getPrototypeOf = __webpack_require__(58); +var createNonEnumerableProperty = __webpack_require__(19); +var has = __webpack_require__(16); +var wellKnownSymbol = __webpack_require__(50); +var IS_PURE = __webpack_require__(30); var ITERATOR = wellKnownSymbol('iterator'); var BUGGY_SAFARI_ITERATORS = false; @@ -1868,13 +1501,13 @@ module.exports = { /***/ }), -/* 69 */ +/* 58 */ /***/ (function(module, exports, __webpack_require__) { -var has = __webpack_require__(17); -var toObject = __webpack_require__(51); -var sharedKey = __webpack_require__(29); -var CORRECT_PROTOTYPE_GETTER = __webpack_require__(70); +var has = __webpack_require__(16); +var toObject = __webpack_require__(59); +var sharedKey = __webpack_require__(28); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(60); var IE_PROTO = sharedKey('IE_PROTO'); var ObjectPrototype = Object.prototype; @@ -1891,10 +1524,23 @@ module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) /***/ }), -/* 70 */ +/* 59 */ +/***/ (function(module, exports, __webpack_require__) { + +var requireObjectCoercible = __webpack_require__(13); + +// `ToObject` abstract operation +// https://tc39.github.io/ecma262/#sec-toobject +module.exports = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + + +/***/ }), +/* 60 */ /***/ (function(module, exports, __webpack_require__) { -var fails = __webpack_require__(8); +var fails = __webpack_require__(7); module.exports = !fails(function () { function F() { /* empty */ } @@ -1904,28 +1550,164 @@ module.exports = !fails(function () { /***/ }), -/* 71 */ +/* 61 */ /***/ (function(module, exports, __webpack_require__) { -var defineProperty = __webpack_require__(21).f; -var has = __webpack_require__(17); -var wellKnownSymbol = __webpack_require__(54); - -var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var anObject = __webpack_require__(21); +var defineProperties = __webpack_require__(62); +var enumBugKeys = __webpack_require__(43); +var hiddenKeys = __webpack_require__(32); +var html = __webpack_require__(64); +var documentCreateElement = __webpack_require__(18); +var sharedKey = __webpack_require__(28); -module.exports = function (it, TAG, STATIC) { - if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { - defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); - } -}; +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); +var EmptyConstructor = function () { /* empty */ }; -/***/ }), -/* 72 */ -/***/ (function(module, exports, __webpack_require__) { +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; -var anObject = __webpack_require__(22); -var aPossiblePrototype = __webpack_require__(73); +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + /* global ActiveXObject */ + activeXDocument = document.domain && new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.github.io/ecma262/#sec-object.create +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : defineProperties(result, Properties); +}; + + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(20); +var anObject = __webpack_require__(21); +var objectKeys = __webpack_require__(63); + +// `Object.defineProperties` method +// https://tc39.github.io/ecma262/#sec-object.defineproperties +module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]); + return O; +}; + + +/***/ }), +/* 63 */ +/***/ (function(module, exports, __webpack_require__) { + +var internalObjectKeys = __webpack_require__(38); +var enumBugKeys = __webpack_require__(43); + +// `Object.keys` method +// https://tc39.github.io/ecma262/#sec-object.keys +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + + +/***/ }), +/* 64 */ +/***/ (function(module, exports, __webpack_require__) { + +var getBuiltIn = __webpack_require__(35); + +module.exports = getBuiltIn('document', 'documentElement'); + + +/***/ }), +/* 65 */ +/***/ (function(module, exports, __webpack_require__) { + +var defineProperty = __webpack_require__(20).f; +var has = __webpack_require__(16); +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +module.exports = function (it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + + +/***/ }), +/* 66 */ +/***/ (function(module, exports) { + +module.exports = {}; + + +/***/ }), +/* 67 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var aPossiblePrototype = __webpack_require__(68); // `Object.setPrototypeOf` method // https://tc39.github.io/ecma262/#sec-object.setprototypeof @@ -1947,32 +1729,994 @@ module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { else O.__proto__ = proto; return O; }; -}() : undefined); +}() : undefined); + + +/***/ }), +/* 68 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); + +module.exports = function (it) { + if (!isObject(it) && it !== null) { + throw TypeError("Can't set " + String(it) + ' as a prototype'); + } return it; +}; + + +/***/ }), +/* 69 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var DOMIterables = __webpack_require__(70); +var ArrayIteratorMethods = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(19); +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var ArrayValues = ArrayIteratorMethods.values; + +for (var COLLECTION_NAME in DOMIterables) { + var Collection = global[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + if (!CollectionPrototype[TO_STRING_TAG]) { + createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); + } + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +} + + +/***/ }), +/* 70 */ +/***/ (function(module, exports) { + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +module.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + + +/***/ }), +/* 71 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(10); +var addToUnscopables = __webpack_require__(72); +var Iterators = __webpack_require__(66); +var InternalStateModule = __webpack_require__(26); +var defineIterator = __webpack_require__(55); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.github.io/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.github.io/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.github.io/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.github.io/ecma262/#sec-createarrayiterator +module.exports = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { value: undefined, done: true }; + } + if (kind == 'keys') return { value: index, done: false }; + if (kind == 'values') return { value: target[index], done: false }; + return { value: [index, target[index]], done: false }; +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject +// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject +Iterators.Arguments = Iterators.Array; + +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + + +/***/ }), +/* 72 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); +var create = __webpack_require__(61); +var definePropertyModule = __webpack_require__(20); + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] == undefined) { + definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + + +/***/ }), +/* 73 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var global = __webpack_require__(3); +var redefineAll = __webpack_require__(74); +var InternalMetadataModule = __webpack_require__(75); +var collection = __webpack_require__(77); +var collectionWeak = __webpack_require__(89); +var isObject = __webpack_require__(15); +var enforceIternalState = __webpack_require__(26).enforce; +var NATIVE_WEAK_MAP = __webpack_require__(27); + +var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global; +var isExtensible = Object.isExtensible; +var InternalWeakMap; + +var wrapper = function (init) { + return function WeakMap() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}; + +// `WeakMap` constructor +// https://tc39.github.io/ecma262/#sec-weakmap-constructor +var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak); + +// IE11 WeakMap frozen keys fix +// We can't use feature detection because it crash some old IE builds +// https://github.com/zloirock/core-js/issues/485 +if (NATIVE_WEAK_MAP && IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + InternalMetadataModule.REQUIRED = true; + var WeakMapPrototype = $WeakMap.prototype; + var nativeDelete = WeakMapPrototype['delete']; + var nativeHas = WeakMapPrototype.has; + var nativeGet = WeakMapPrototype.get; + var nativeSet = WeakMapPrototype.set; + redefineAll(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeDelete.call(this, key) || state.frozen['delete'](key); + } return nativeDelete.call(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) || state.frozen.has(key); + } return nativeHas.call(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); + } return nativeGet.call(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); + } else nativeSet.call(this, key, value); + return this; + } + }); +} + + +/***/ }), +/* 74 */ +/***/ (function(module, exports, __webpack_require__) { + +var redefine = __webpack_require__(22); + +module.exports = function (target, src, options) { + for (var key in src) redefine(target, key, src[key], options); + return target; +}; + + +/***/ }), +/* 75 */ +/***/ (function(module, exports, __webpack_require__) { + +var hiddenKeys = __webpack_require__(32); +var isObject = __webpack_require__(15); +var has = __webpack_require__(16); +var defineProperty = __webpack_require__(20).f; +var uid = __webpack_require__(31); +var FREEZING = __webpack_require__(76); + +var METADATA = uid('meta'); +var id = 0; + +var isExtensible = Object.isExtensible || function () { + return true; +}; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + ++id, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!has(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); + return it; +}; + +var meta = module.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + + +/***/ }), +/* 76 */ +/***/ (function(module, exports, __webpack_require__) { + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + return Object.isExtensible(Object.preventExtensions({})); +}); + + +/***/ }), +/* 77 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var isForced = __webpack_require__(45); +var redefine = __webpack_require__(22); +var InternalMetadataModule = __webpack_require__(75); +var iterate = __webpack_require__(78); +var anInstance = __webpack_require__(86); +var isObject = __webpack_require__(15); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(87); +var setToStringTag = __webpack_require__(65); +var inheritIfRequired = __webpack_require__(88); + +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, + KEY == 'add' ? function add(value) { + nativeMethod.call(this, value === 0 ? 0 : value); + return this; + } : KEY == 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : function set(key, value) { + nativeMethod.call(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + // eslint-disable-next-line max-len + if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })))) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.REQUIRED = true; + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + 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 && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, forced: Constructor != NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + + +/***/ }), +/* 78 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); +var isArrayIteratorMethod = __webpack_require__(79); +var toLength = __webpack_require__(40); +var bind = __webpack_require__(80); +var getIteratorMethod = __webpack_require__(82); +var callWithSafeIterationClosing = __webpack_require__(85); + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) { + var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1); + var iterator, iterFn, index, length, result, next, step; + + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = toLength(iterable.length); length > index; index++) { + result = AS_ENTRIES + ? boundFunction(anObject(step = iterable[index])[0], step[1]) + : boundFunction(iterable[index]); + if (result && result instanceof Result) return result; + } return new Result(false); + } + iterator = iterFn.call(iterable); + } + + next = iterator.next; + while (!(step = next.call(iterator)).done) { + result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES); + if (typeof result == 'object' && result && result instanceof Result) return result; + } return new Result(false); +}; + +iterate.stop = function (result) { + return new Result(true, result); +}; + + +/***/ }), +/* 79 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); +var Iterators = __webpack_require__(66); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + + +/***/ }), +/* 80 */ +/***/ (function(module, exports, __webpack_require__) { + +var aFunction = __webpack_require__(81); + +// optional / simple context binding +module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 0: return function () { + return fn.call(that); + }; + 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); + }; +}; + + +/***/ }), +/* 81 */ +/***/ (function(module, exports) { + +module.exports = function (it) { + if (typeof it != 'function') { + throw TypeError(String(it) + ' is not a function'); + } return it; +}; + + +/***/ }), +/* 82 */ +/***/ (function(module, exports, __webpack_require__) { + +var classof = __webpack_require__(83); +var Iterators = __webpack_require__(66); +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); + +module.exports = function (it) { + if (it != undefined) return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; +}; + + +/***/ }), +/* 83 */ +/***/ (function(module, exports, __webpack_require__) { + +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var classofRaw = __webpack_require__(12); +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; +}; + + +/***/ }), +/* 84 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; + +test[TO_STRING_TAG] = 'z'; + +module.exports = String(test) === '[object z]'; + + +/***/ }), +/* 85 */ +/***/ (function(module, exports, __webpack_require__) { + +var anObject = __webpack_require__(21); + +// call something on iterator step with safe closing on error +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 (error) { + var returnMethod = iterator['return']; + if (returnMethod !== undefined) anObject(returnMethod.call(iterator)); + throw error; + } +}; + + +/***/ }), +/* 86 */ +/***/ (function(module, exports) { + +module.exports = function (it, Constructor, name) { + if (!(it instanceof Constructor)) { + throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); + } return it; +}; + + +/***/ }), +/* 87 */ +/***/ (function(module, exports, __webpack_require__) { + +var wellKnownSymbol = __webpack_require__(50); + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line no-throw-literal + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +module.exports = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + + +/***/ }), +/* 88 */ +/***/ (function(module, exports, __webpack_require__) { + +var isObject = __webpack_require__(15); +var setPrototypeOf = __webpack_require__(67); + +// makes subclassing work correct for wrapped built-ins +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + typeof (NewTarget = dummy.constructor) == 'function' && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + + +/***/ }), +/* 89 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var redefineAll = __webpack_require__(74); +var getWeakData = __webpack_require__(75).getWeakData; +var anObject = __webpack_require__(21); +var isObject = __webpack_require__(15); +var anInstance = __webpack_require__(86); +var iterate = __webpack_require__(78); +var ArrayIterationModule = __webpack_require__(90); +var $has = __webpack_require__(16); +var InternalStateModule = __webpack_require__(26); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (store) { + return store.frozen || (store.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) this.entries.splice(index, 1); + return !!~index; + } +}; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP); + }); + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + redefineAll(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && $has(data, state.id) && delete data[state.id]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && $has(data, state.id); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.3.3.3 WeakMap.prototype.get(key) + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // 23.3.3.5 WeakMap.prototype.set(key, value) + set: function set(key, value) { + return define(this, key, value); + } + } : { + // 23.4.3.1 WeakSet.prototype.add(value) + add: function add(value) { + return define(this, value, true); + } + }); + + return C; + } +}; + + +/***/ }), +/* 90 */ +/***/ (function(module, exports, __webpack_require__) { + +var bind = __webpack_require__(80); +var IndexedObject = __webpack_require__(11); +var toObject = __webpack_require__(59); +var toLength = __webpack_require__(40); +var arraySpeciesCreate = __webpack_require__(91); + +var push = [].push; + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push.call(target, value); // filter + } else if (IS_EVERY) return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +module.exports = { + // `Array.prototype.forEach` method + // https://tc39.github.io/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.github.io/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.github.io/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.github.io/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.github.io/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.github.io/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6) +}; /***/ }), -/* 73 */ +/* 91 */ /***/ (function(module, exports, __webpack_require__) { -var isObject = __webpack_require__(16); +var isObject = __webpack_require__(15); +var isArray = __webpack_require__(92); +var wellKnownSymbol = __webpack_require__(50); -module.exports = function (it) { - if (!isObject(it) && it !== null) { - throw TypeError("Can't set " + String(it) + ' as a prototype'); - } return it; +var SPECIES = wellKnownSymbol('species'); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.github.io/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray, length) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); }; /***/ }), -/* 74 */ +/* 92 */ +/***/ (function(module, exports, __webpack_require__) { + +var classof = __webpack_require__(12); + +// `IsArray` abstract operation +// https://tc39.github.io/ecma262/#sec-isarray +module.exports = Array.isArray || function isArray(arg) { + return classof(arg) == 'Array'; +}; + + +/***/ }), +/* 93 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var fails = __webpack_require__(7); +var toIndexedObject = __webpack_require__(10); +var nativeGetOwnPropertyDescriptor = __webpack_require__(5).f; +var DESCRIPTORS = __webpack_require__(6); + +var FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); }); +var FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor +$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { + return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); + } +}); + + +/***/ }), +/* 94 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $ = __webpack_require__(3); -var $reduce = __webpack_require__(75).left; -var arrayMethodIsStrict = __webpack_require__(57); -var arrayMethodUsesToLength = __webpack_require__(58); +var $ = __webpack_require__(2); +var $reduce = __webpack_require__(95).left; +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); var STRICT_METHOD = arrayMethodIsStrict('reduce'); var USES_TO_LENGTH = arrayMethodUsesToLength('reduce', { 1: 0 }); @@ -1987,13 +2731,13 @@ $({ target: 'Array', proto: true, forced: !STRICT_METHOD || !USES_TO_LENGTH }, { /***/ }), -/* 75 */ +/* 95 */ /***/ (function(module, exports, __webpack_require__) { -var aFunction = __webpack_require__(50); -var toObject = __webpack_require__(51); -var IndexedObject = __webpack_require__(12); -var toLength = __webpack_require__(41); +var aFunction = __webpack_require__(81); +var toObject = __webpack_require__(59); +var IndexedObject = __webpack_require__(11); +var toLength = __webpack_require__(40); // `Array.prototype.{ reduce, reduceRight }` methods implementation var createMethod = function (IS_RIGHT) { @@ -2033,151 +2777,99 @@ module.exports = { /***/ }), -/* 76 */ +/* 96 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $ = __webpack_require__(3); -var isObject = __webpack_require__(16); -var isArray = __webpack_require__(53); -var toAbsoluteIndex = __webpack_require__(43); -var toLength = __webpack_require__(41); -var toIndexedObject = __webpack_require__(11); -var createProperty = __webpack_require__(77); -var wellKnownSymbol = __webpack_require__(54); -var arrayMethodHasSpeciesSupport = __webpack_require__(78); -var arrayMethodUsesToLength = __webpack_require__(58); - -var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice'); -var USES_TO_LENGTH = arrayMethodUsesToLength('slice', { ACCESSORS: true, 0: 0, 1: 2 }); - -var SPECIES = wellKnownSymbol('species'); -var nativeSlice = [].slice; -var max = Math.max; +var fails = __webpack_require__(7); -// `Array.prototype.slice` method -// https://tc39.github.io/ecma262/#sec-array.prototype.slice -// fallback for not array-like ES3 strings and DOM objects -$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { - slice: function slice(start, end) { - var O = toIndexedObject(this); - var length = toLength(O.length); - var k = toAbsoluteIndex(start, length); - var fin = toAbsoluteIndex(end === undefined ? length : end, length); - // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible - var Constructor, result, n; - if (isArray(O)) { - Constructor = O.constructor; - // cross-realm fallback - if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { - Constructor = undefined; - } else if (isObject(Constructor)) { - Constructor = Constructor[SPECIES]; - if (Constructor === null) Constructor = undefined; - } - if (Constructor === Array || Constructor === undefined) { - return nativeSlice.call(O, k, fin); - } - } - result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0)); - for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); - result.length = n; - return result; - } -}); +module.exports = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function () { + // eslint-disable-next-line no-useless-call,no-throw-literal + method.call(null, argument || function () { throw 1; }, 1); + }); +}; /***/ }), -/* 77 */ +/* 97 */ /***/ (function(module, exports, __webpack_require__) { -"use strict"; - -var toPrimitive = __webpack_require__(15); -var definePropertyModule = __webpack_require__(21); -var createPropertyDescriptor = __webpack_require__(10); +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var has = __webpack_require__(16); -module.exports = function (object, key, value) { - var propertyKey = toPrimitive(key); - if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); - else object[propertyKey] = value; -}; +var defineProperty = Object.defineProperty; +var cache = {}; +var thrower = function (it) { throw it; }; -/***/ }), -/* 78 */ -/***/ (function(module, exports, __webpack_require__) { +module.exports = function (METHOD_NAME, options) { + if (has(cache, METHOD_NAME)) return cache[METHOD_NAME]; + if (!options) options = {}; + var method = [][METHOD_NAME]; + var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false; + var argument0 = has(options, 0) ? options[0] : thrower; + var argument1 = has(options, 1) ? options[1] : undefined; -var fails = __webpack_require__(8); -var wellKnownSymbol = __webpack_require__(54); -var V8_VERSION = __webpack_require__(79); + return cache[METHOD_NAME] = !!method && !fails(function () { + if (ACCESSORS && !DESCRIPTORS) return true; + var O = { length: -1 }; -var SPECIES = wellKnownSymbol('species'); + if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower }); + else O[1] = 1; -module.exports = function (METHOD_NAME) { - // We can't use this feature detection in V8 since it causes - // deoptimization and serious performance degradation - // https://github.com/zloirock/core-js/issues/677 - return V8_VERSION >= 51 || !fails(function () { - var array = []; - var constructor = array.constructor = {}; - constructor[SPECIES] = function () { - return { foo: 1 }; - }; - return array[METHOD_NAME](Boolean).foo !== 1; + method.call(O, argument0, argument1); }); }; /***/ }), -/* 79 */ +/* 98 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var userAgent = __webpack_require__(80); - -var process = global.process; -var versions = process && process.versions; -var v8 = versions && versions.v8; -var match, version; +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var redefine = __webpack_require__(22); +var toString = __webpack_require__(99); -if (v8) { - match = v8.split('.'); - version = match[0] + match[1]; -} else if (userAgent) { - match = userAgent.match(/Edge\/(\d+)/); - if (!match || match[1] >= 74) { - match = userAgent.match(/Chrome\/(\d+)/); - if (match) version = match[1]; - } +// `Object.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + redefine(Object.prototype, 'toString', toString, { unsafe: true }); } -module.exports = version && +version; - /***/ }), -/* 80 */ +/* 99 */ /***/ (function(module, exports, __webpack_require__) { -var getBuiltIn = __webpack_require__(36); +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(84); +var classof = __webpack_require__(83); -module.exports = getBuiltIn('navigator', 'userAgent') || ''; +// `Object.prototype.toString` method implementation +// https://tc39.github.io/ecma262/#sec-object.prototype.tostring +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; /***/ }), -/* 81 */ +/* 100 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $ = __webpack_require__(3); -var fails = __webpack_require__(8); -var ArrayBufferModule = __webpack_require__(82); -var anObject = __webpack_require__(22); -var toAbsoluteIndex = __webpack_require__(43); -var toLength = __webpack_require__(41); -var speciesConstructor = __webpack_require__(89); +var $ = __webpack_require__(2); +var fails = __webpack_require__(7); +var ArrayBufferModule = __webpack_require__(101); +var anObject = __webpack_require__(21); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); +var speciesConstructor = __webpack_require__(106); var ArrayBuffer = ArrayBufferModule.ArrayBuffer; var DataView = ArrayBufferModule.DataView; @@ -2209,29 +2901,29 @@ $({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, /***/ }), -/* 82 */ +/* 101 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var global = __webpack_require__(4); -var DESCRIPTORS = __webpack_require__(7); -var NATIVE_ARRAY_BUFFER = __webpack_require__(83); -var createNonEnumerableProperty = __webpack_require__(20); -var redefineAll = __webpack_require__(84); -var fails = __webpack_require__(8); -var anInstance = __webpack_require__(85); -var toInteger = __webpack_require__(42); -var toLength = __webpack_require__(41); -var toIndex = __webpack_require__(86); -var IEEE754 = __webpack_require__(87); -var getPrototypeOf = __webpack_require__(69); -var setPrototypeOf = __webpack_require__(72); -var getOwnPropertyNames = __webpack_require__(38).f; -var defineProperty = __webpack_require__(21).f; -var arrayFill = __webpack_require__(88); -var setToStringTag = __webpack_require__(71); -var InternalStateModule = __webpack_require__(27); +var global = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_ARRAY_BUFFER = __webpack_require__(102); +var createNonEnumerableProperty = __webpack_require__(19); +var redefineAll = __webpack_require__(74); +var fails = __webpack_require__(7); +var anInstance = __webpack_require__(86); +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); +var toIndex = __webpack_require__(103); +var IEEE754 = __webpack_require__(104); +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var getOwnPropertyNames = __webpack_require__(37).f; +var defineProperty = __webpack_require__(20).f; +var arrayFill = __webpack_require__(105); +var setToStringTag = __webpack_require__(65); +var InternalStateModule = __webpack_require__(26); var getInternalState = InternalStateModule.get; var setInternalState = InternalStateModule.set; @@ -2442,41 +3134,18 @@ module.exports = { /***/ }), -/* 83 */ +/* 102 */ /***/ (function(module, exports) { module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined'; /***/ }), -/* 84 */ -/***/ (function(module, exports, __webpack_require__) { - -var redefine = __webpack_require__(23); - -module.exports = function (target, src, options) { - for (var key in src) redefine(target, key, src[key], options); - return target; -}; - - -/***/ }), -/* 85 */ -/***/ (function(module, exports) { - -module.exports = function (it, Constructor, name) { - if (!(it instanceof Constructor)) { - throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); - } return it; -}; - - -/***/ }), -/* 86 */ +/* 103 */ /***/ (function(module, exports, __webpack_require__) { -var toInteger = __webpack_require__(42); -var toLength = __webpack_require__(41); +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); // `ToIndex` abstract operation // https://tc39.github.io/ecma262/#sec-toindex @@ -2490,7 +3159,7 @@ module.exports = function (it) { /***/ }), -/* 87 */ +/* 104 */ /***/ (function(module, exports) { // IEEE754 conversions based on https://github.com/feross/ieee754 @@ -2584,14 +3253,14 @@ module.exports = { /***/ }), -/* 88 */ +/* 105 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var toObject = __webpack_require__(51); -var toAbsoluteIndex = __webpack_require__(43); -var toLength = __webpack_require__(41); +var toObject = __webpack_require__(59); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); // `Array.prototype.fill` method implementation // https://tc39.github.io/ecma262/#sec-array.prototype.fill @@ -2608,12 +3277,12 @@ module.exports = function fill(value /* , start = 0, end = @length */) { /***/ }), -/* 89 */ +/* 106 */ /***/ (function(module, exports, __webpack_require__) { -var anObject = __webpack_require__(22); -var aFunction = __webpack_require__(50); -var wellKnownSymbol = __webpack_require__(54); +var anObject = __webpack_require__(21); +var aFunction = __webpack_require__(81); +var wellKnownSymbol = __webpack_require__(50); var SPECIES = wellKnownSymbol('species'); @@ -2627,87 +3296,10 @@ module.exports = function (O, defaultConstructor) { /***/ }), -/* 90 */ -/***/ (function(module, exports, __webpack_require__) { - -var TO_STRING_TAG_SUPPORT = __webpack_require__(91); -var redefine = __webpack_require__(23); -var toString = __webpack_require__(92); - -// `Object.prototype.toString` method -// https://tc39.github.io/ecma262/#sec-object.prototype.tostring -if (!TO_STRING_TAG_SUPPORT) { - redefine(Object.prototype, 'toString', toString, { unsafe: true }); -} - - -/***/ }), -/* 91 */ -/***/ (function(module, exports, __webpack_require__) { - -var wellKnownSymbol = __webpack_require__(54); - -var TO_STRING_TAG = wellKnownSymbol('toStringTag'); -var test = {}; - -test[TO_STRING_TAG] = 'z'; - -module.exports = String(test) === '[object z]'; - - -/***/ }), -/* 92 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var TO_STRING_TAG_SUPPORT = __webpack_require__(91); -var classof = __webpack_require__(93); - -// `Object.prototype.toString` method implementation -// https://tc39.github.io/ecma262/#sec-object.prototype.tostring -module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { - return '[object ' + classof(this) + ']'; -}; - - -/***/ }), -/* 93 */ -/***/ (function(module, exports, __webpack_require__) { - -var TO_STRING_TAG_SUPPORT = __webpack_require__(91); -var classofRaw = __webpack_require__(13); -var wellKnownSymbol = __webpack_require__(54); - -var TO_STRING_TAG = wellKnownSymbol('toStringTag'); -// ES3 wrong here -var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; - -// fallback for IE11 Script Access Denied error -var tryGet = function (it, key) { - try { - return it[key]; - } catch (error) { /* empty */ } -}; - -// getting tag from ES6+ `Object.prototype.toString` -module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { - var O, tag, result; - return it === undefined ? 'Undefined' : it === null ? 'Null' - // @@toStringTag case - : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag - // builtinTag case - : CORRECT_ARGUMENTS ? classofRaw(O) - // ES3 arguments fallback - : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; -}; - - -/***/ }), -/* 94 */ +/* 107 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); // `Uint8Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects @@ -2719,37 +3311,37 @@ createTypedArrayConstructor('Uint8', function (init) { /***/ }), -/* 95 */ +/* 108 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $ = __webpack_require__(3); -var global = __webpack_require__(4); -var DESCRIPTORS = __webpack_require__(7); -var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(96); -var ArrayBufferViewCore = __webpack_require__(98); -var ArrayBufferModule = __webpack_require__(82); -var anInstance = __webpack_require__(85); -var createPropertyDescriptor = __webpack_require__(10); -var createNonEnumerableProperty = __webpack_require__(20); -var toLength = __webpack_require__(41); -var toIndex = __webpack_require__(86); -var toOffset = __webpack_require__(99); -var toPrimitive = __webpack_require__(15); -var has = __webpack_require__(17); -var classof = __webpack_require__(93); -var isObject = __webpack_require__(16); +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(109); +var ArrayBufferViewCore = __webpack_require__(110); +var ArrayBufferModule = __webpack_require__(101); +var anInstance = __webpack_require__(86); +var createPropertyDescriptor = __webpack_require__(9); +var createNonEnumerableProperty = __webpack_require__(19); +var toLength = __webpack_require__(40); +var toIndex = __webpack_require__(103); +var toOffset = __webpack_require__(111); +var toPrimitive = __webpack_require__(14); +var has = __webpack_require__(16); +var classof = __webpack_require__(83); +var isObject = __webpack_require__(15); var create = __webpack_require__(61); -var setPrototypeOf = __webpack_require__(72); -var getOwnPropertyNames = __webpack_require__(38).f; -var typedArrayFrom = __webpack_require__(101); -var forEach = __webpack_require__(48).forEach; -var setSpecies = __webpack_require__(104); -var definePropertyModule = __webpack_require__(21); -var getOwnPropertyDescriptorModule = __webpack_require__(6); -var InternalStateModule = __webpack_require__(27); -var inheritIfRequired = __webpack_require__(105); +var setPrototypeOf = __webpack_require__(67); +var getOwnPropertyNames = __webpack_require__(37).f; +var typedArrayFrom = __webpack_require__(113); +var forEach = __webpack_require__(90).forEach; +var setSpecies = __webpack_require__(114); +var definePropertyModule = __webpack_require__(20); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var InternalStateModule = __webpack_require__(26); +var inheritIfRequired = __webpack_require__(88); var getInternalState = InternalStateModule.get; var setInternalState = InternalStateModule.set; @@ -2956,14 +3548,14 @@ if (DESCRIPTORS) { /***/ }), -/* 96 */ +/* 109 */ /***/ (function(module, exports, __webpack_require__) { /* eslint-disable no-new */ -var global = __webpack_require__(4); -var fails = __webpack_require__(8); -var checkCorrectnessOfIteration = __webpack_require__(97); -var NATIVE_ARRAY_BUFFER_VIEWS = __webpack_require__(98).NATIVE_ARRAY_BUFFER_VIEWS; +var global = __webpack_require__(3); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(87); +var NATIVE_ARRAY_BUFFER_VIEWS = __webpack_require__(110).NATIVE_ARRAY_BUFFER_VIEWS; var ArrayBuffer = global.ArrayBuffer; var Int8Array = global.Int8Array; @@ -2984,68 +3576,24 @@ module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () { /***/ }), -/* 97 */ -/***/ (function(module, exports, __webpack_require__) { - -var wellKnownSymbol = __webpack_require__(54); - -var ITERATOR = wellKnownSymbol('iterator'); -var SAFE_CLOSING = false; - -try { - var called = 0; - var iteratorWithReturn = { - next: function () { - return { done: !!called++ }; - }, - 'return': function () { - SAFE_CLOSING = true; - } - }; - iteratorWithReturn[ITERATOR] = function () { - return this; - }; - // eslint-disable-next-line no-throw-literal - Array.from(iteratorWithReturn, function () { throw 2; }); -} catch (error) { /* empty */ } - -module.exports = function (exec, SKIP_CLOSING) { - if (!SKIP_CLOSING && !SAFE_CLOSING) return false; - var ITERATION_SUPPORT = false; - try { - var object = {}; - object[ITERATOR] = function () { - return { - next: function () { - return { done: ITERATION_SUPPORT = true }; - } - }; - }; - exec(object); - } catch (error) { /* empty */ } - return ITERATION_SUPPORT; -}; - - -/***/ }), -/* 98 */ +/* 110 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var NATIVE_ARRAY_BUFFER = __webpack_require__(83); -var DESCRIPTORS = __webpack_require__(7); -var global = __webpack_require__(4); -var isObject = __webpack_require__(16); -var has = __webpack_require__(17); -var classof = __webpack_require__(93); -var createNonEnumerableProperty = __webpack_require__(20); -var redefine = __webpack_require__(23); -var defineProperty = __webpack_require__(21).f; -var getPrototypeOf = __webpack_require__(69); -var setPrototypeOf = __webpack_require__(72); -var wellKnownSymbol = __webpack_require__(54); -var uid = __webpack_require__(32); +var NATIVE_ARRAY_BUFFER = __webpack_require__(102); +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var isObject = __webpack_require__(15); +var has = __webpack_require__(16); +var classof = __webpack_require__(83); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var defineProperty = __webpack_require__(20).f; +var getPrototypeOf = __webpack_require__(58); +var setPrototypeOf = __webpack_require__(67); +var wellKnownSymbol = __webpack_require__(50); +var uid = __webpack_require__(31); var Int8Array = global.Int8Array; var Int8ArrayPrototype = Int8Array && Int8Array.prototype; @@ -3191,10 +3739,10 @@ module.exports = { /***/ }), -/* 99 */ +/* 111 */ /***/ (function(module, exports, __webpack_require__) { -var toPositiveInteger = __webpack_require__(100); +var toPositiveInteger = __webpack_require__(112); module.exports = function (it, BYTES) { var offset = toPositiveInteger(it); @@ -3204,10 +3752,10 @@ module.exports = function (it, BYTES) { /***/ }), -/* 100 */ +/* 112 */ /***/ (function(module, exports, __webpack_require__) { -var toInteger = __webpack_require__(42); +var toInteger = __webpack_require__(41); module.exports = function (it) { var result = toInteger(it); @@ -3217,15 +3765,15 @@ module.exports = function (it) { /***/ }), -/* 101 */ +/* 113 */ /***/ (function(module, exports, __webpack_require__) { -var toObject = __webpack_require__(51); -var toLength = __webpack_require__(41); -var getIteratorMethod = __webpack_require__(102); -var isArrayIteratorMethod = __webpack_require__(103); -var bind = __webpack_require__(49); -var aTypedArrayConstructor = __webpack_require__(98).aTypedArrayConstructor; +var toObject = __webpack_require__(59); +var toLength = __webpack_require__(40); +var getIteratorMethod = __webpack_require__(82); +var isArrayIteratorMethod = __webpack_require__(79); +var bind = __webpack_require__(80); +var aTypedArrayConstructor = __webpack_require__(110).aTypedArrayConstructor; module.exports = function from(source /* , mapfn, thisArg */) { var O = toObject(source); @@ -3255,48 +3803,15 @@ module.exports = function from(source /* , mapfn, thisArg */) { /***/ }), -/* 102 */ -/***/ (function(module, exports, __webpack_require__) { - -var classof = __webpack_require__(93); -var Iterators = __webpack_require__(65); -var wellKnownSymbol = __webpack_require__(54); - -var ITERATOR = wellKnownSymbol('iterator'); - -module.exports = function (it) { - if (it != undefined) return it[ITERATOR] - || it['@@iterator'] - || Iterators[classof(it)]; -}; - - -/***/ }), -/* 103 */ -/***/ (function(module, exports, __webpack_require__) { - -var wellKnownSymbol = __webpack_require__(54); -var Iterators = __webpack_require__(65); - -var ITERATOR = wellKnownSymbol('iterator'); -var ArrayPrototype = Array.prototype; - -// check on default Array iterator -module.exports = function (it) { - return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); -}; - - -/***/ }), -/* 104 */ +/* 114 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var getBuiltIn = __webpack_require__(36); -var definePropertyModule = __webpack_require__(21); -var wellKnownSymbol = __webpack_require__(54); -var DESCRIPTORS = __webpack_require__(7); +var getBuiltIn = __webpack_require__(35); +var definePropertyModule = __webpack_require__(20); +var wellKnownSymbol = __webpack_require__(50); +var DESCRIPTORS = __webpack_require__(6); var SPECIES = wellKnownSymbol('species'); @@ -3314,36 +3829,13 @@ module.exports = function (CONSTRUCTOR_NAME) { /***/ }), -/* 105 */ -/***/ (function(module, exports, __webpack_require__) { - -var isObject = __webpack_require__(16); -var setPrototypeOf = __webpack_require__(72); - -// makes subclassing work correct for wrapped built-ins -module.exports = function ($this, dummy, Wrapper) { - var NewTarget, NewTargetPrototype; - if ( - // it can work only with native `setPrototypeOf` - setPrototypeOf && - // we haven't completely correct pre-ES6 way for getting `new.target`, so use this - typeof (NewTarget = dummy.constructor) == 'function' && - NewTarget !== Wrapper && - isObject(NewTargetPrototype = NewTarget.prototype) && - NewTargetPrototype !== Wrapper.prototype - ) setPrototypeOf($this, NewTargetPrototype); - return $this; -}; - - -/***/ }), -/* 106 */ +/* 115 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $copyWithin = __webpack_require__(107); +var ArrayBufferViewCore = __webpack_require__(110); +var $copyWithin = __webpack_require__(116); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3356,14 +3848,14 @@ exportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end /***/ }), -/* 107 */ +/* 116 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var toObject = __webpack_require__(51); -var toAbsoluteIndex = __webpack_require__(43); -var toLength = __webpack_require__(41); +var toObject = __webpack_require__(59); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); var min = Math.min; @@ -3392,13 +3884,13 @@ module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* /***/ }), -/* 108 */ +/* 117 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $every = __webpack_require__(48).every; +var ArrayBufferViewCore = __webpack_require__(110); +var $every = __webpack_require__(90).every; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3411,13 +3903,13 @@ exportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) { /***/ }), -/* 109 */ +/* 118 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $fill = __webpack_require__(88); +var ArrayBufferViewCore = __webpack_require__(110); +var $fill = __webpack_require__(105); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3431,14 +3923,14 @@ exportTypedArrayMethod('fill', function fill(value /* , start, end */) { /***/ }), -/* 110 */ +/* 119 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $filter = __webpack_require__(48).filter; -var speciesConstructor = __webpack_require__(89); +var ArrayBufferViewCore = __webpack_require__(110); +var $filter = __webpack_require__(90).filter; +var speciesConstructor = __webpack_require__(106); var aTypedArray = ArrayBufferViewCore.aTypedArray; var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; @@ -3458,13 +3950,13 @@ exportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) { /***/ }), -/* 111 */ +/* 120 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $find = __webpack_require__(48).find; +var ArrayBufferViewCore = __webpack_require__(110); +var $find = __webpack_require__(90).find; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3477,13 +3969,13 @@ exportTypedArrayMethod('find', function find(predicate /* , thisArg */) { /***/ }), -/* 112 */ +/* 121 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $findIndex = __webpack_require__(48).findIndex; +var ArrayBufferViewCore = __webpack_require__(110); +var $findIndex = __webpack_require__(90).findIndex; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3496,13 +3988,13 @@ exportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */ /***/ }), -/* 113 */ +/* 122 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $forEach = __webpack_require__(48).forEach; +var ArrayBufferViewCore = __webpack_require__(110); +var $forEach = __webpack_require__(90).forEach; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3515,13 +4007,13 @@ exportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) { /***/ }), -/* 114 */ +/* 123 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $includes = __webpack_require__(40).includes; +var ArrayBufferViewCore = __webpack_require__(110); +var $includes = __webpack_require__(39).includes; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3534,13 +4026,13 @@ exportTypedArrayMethod('includes', function includes(searchElement /* , fromInde /***/ }), -/* 115 */ +/* 124 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $indexOf = __webpack_require__(40).indexOf; +var ArrayBufferViewCore = __webpack_require__(110); +var $indexOf = __webpack_require__(39).indexOf; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3553,15 +4045,15 @@ exportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex /***/ }), -/* 116 */ +/* 125 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var global = __webpack_require__(4); -var ArrayBufferViewCore = __webpack_require__(98); -var ArrayIterators = __webpack_require__(59); -var wellKnownSymbol = __webpack_require__(54); +var global = __webpack_require__(3); +var ArrayBufferViewCore = __webpack_require__(110); +var ArrayIterators = __webpack_require__(71); +var wellKnownSymbol = __webpack_require__(50); var ITERATOR = wellKnownSymbol('iterator'); var Uint8Array = global.Uint8Array; @@ -3598,12 +4090,12 @@ exportTypedArrayMethod(ITERATOR, typedArrayValues, !CORRECT_ITER_NAME); /***/ }), -/* 117 */ +/* 126 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); +var ArrayBufferViewCore = __webpack_require__(110); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3618,13 +4110,13 @@ exportTypedArrayMethod('join', function join(separator) { /***/ }), -/* 118 */ +/* 127 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $lastIndexOf = __webpack_require__(119); +var ArrayBufferViewCore = __webpack_require__(110); +var $lastIndexOf = __webpack_require__(128); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3638,16 +4130,16 @@ exportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fr /***/ }), -/* 119 */ +/* 128 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var toIndexedObject = __webpack_require__(11); -var toInteger = __webpack_require__(42); -var toLength = __webpack_require__(41); -var arrayMethodIsStrict = __webpack_require__(57); -var arrayMethodUsesToLength = __webpack_require__(58); +var toIndexedObject = __webpack_require__(10); +var toInteger = __webpack_require__(41); +var toLength = __webpack_require__(40); +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); var min = Math.min; var nativeLastIndexOf = [].lastIndexOf; @@ -3673,14 +4165,14 @@ module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[ /***/ }), -/* 120 */ +/* 129 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $map = __webpack_require__(48).map; -var speciesConstructor = __webpack_require__(89); +var ArrayBufferViewCore = __webpack_require__(110); +var $map = __webpack_require__(90).map; +var speciesConstructor = __webpack_require__(106); var aTypedArray = ArrayBufferViewCore.aTypedArray; var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; @@ -3696,13 +4188,13 @@ exportTypedArrayMethod('map', function map(mapfn /* , thisArg */) { /***/ }), -/* 121 */ +/* 130 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $reduce = __webpack_require__(75).left; +var ArrayBufferViewCore = __webpack_require__(110); +var $reduce = __webpack_require__(95).left; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3715,13 +4207,13 @@ exportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */ /***/ }), -/* 122 */ +/* 131 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $reduceRight = __webpack_require__(75).right; +var ArrayBufferViewCore = __webpack_require__(110); +var $reduceRight = __webpack_require__(95).right; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3734,12 +4226,12 @@ exportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initi /***/ }), -/* 123 */ +/* 132 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); +var ArrayBufferViewCore = __webpack_require__(110); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3762,16 +4254,16 @@ exportTypedArrayMethod('reverse', function reverse() { /***/ }), -/* 124 */ +/* 133 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var toLength = __webpack_require__(41); -var toOffset = __webpack_require__(99); -var toObject = __webpack_require__(51); -var fails = __webpack_require__(8); +var ArrayBufferViewCore = __webpack_require__(110); +var toLength = __webpack_require__(40); +var toOffset = __webpack_require__(111); +var toObject = __webpack_require__(59); +var fails = __webpack_require__(7); var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3796,14 +4288,14 @@ exportTypedArrayMethod('set', function set(arrayLike /* , offset */) { /***/ }), -/* 125 */ +/* 134 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var speciesConstructor = __webpack_require__(89); -var fails = __webpack_require__(8); +var ArrayBufferViewCore = __webpack_require__(110); +var speciesConstructor = __webpack_require__(106); +var fails = __webpack_require__(7); var aTypedArray = ArrayBufferViewCore.aTypedArray; var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; @@ -3829,13 +4321,13 @@ exportTypedArrayMethod('slice', function slice(start, end) { /***/ }), -/* 126 */ +/* 135 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var ArrayBufferViewCore = __webpack_require__(98); -var $some = __webpack_require__(48).some; +var ArrayBufferViewCore = __webpack_require__(110); +var $some = __webpack_require__(90).some; var aTypedArray = ArrayBufferViewCore.aTypedArray; var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; @@ -3848,513 +4340,391 @@ exportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) { /***/ }), -/* 127 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var ArrayBufferViewCore = __webpack_require__(98); - -var aTypedArray = ArrayBufferViewCore.aTypedArray; -var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; -var $sort = [].sort; - -// `%TypedArray%.prototype.sort` method -// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort -exportTypedArrayMethod('sort', function sort(comparefn) { - return $sort.call(aTypedArray(this), comparefn); -}); - - -/***/ }), -/* 128 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var ArrayBufferViewCore = __webpack_require__(98); -var toLength = __webpack_require__(41); -var toAbsoluteIndex = __webpack_require__(43); -var speciesConstructor = __webpack_require__(89); - -var aTypedArray = ArrayBufferViewCore.aTypedArray; -var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; - -// `%TypedArray%.prototype.subarray` method -// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray -exportTypedArrayMethod('subarray', function subarray(begin, end) { - var O = aTypedArray(this); - var length = O.length; - var beginIndex = toAbsoluteIndex(begin, length); - return new (speciesConstructor(O, O.constructor))( - O.buffer, - O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, - toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) - ); -}); - - -/***/ }), -/* 129 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var global = __webpack_require__(4); -var ArrayBufferViewCore = __webpack_require__(98); -var fails = __webpack_require__(8); - -var Int8Array = global.Int8Array; -var aTypedArray = ArrayBufferViewCore.aTypedArray; -var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; -var $toLocaleString = [].toLocaleString; -var $slice = [].slice; - -// iOS Safari 6.x fails here -var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () { - $toLocaleString.call(new Int8Array(1)); -}); - -var FORCED = fails(function () { - return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString(); -}) || !fails(function () { - Int8Array.prototype.toLocaleString.call([1, 2]); -}); - -// `%TypedArray%.prototype.toLocaleString` method -// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring -exportTypedArrayMethod('toLocaleString', function toLocaleString() { - return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments); -}, FORCED); - - -/***/ }), -/* 130 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -var exportTypedArrayMethod = __webpack_require__(98).exportTypedArrayMethod; -var fails = __webpack_require__(8); -var global = __webpack_require__(4); - -var Uint8Array = global.Uint8Array; -var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {}; -var arrayToString = [].toString; -var arrayJoin = [].join; - -if (fails(function () { arrayToString.call({}); })) { - arrayToString = function toString() { - return arrayJoin.call(this); - }; -} - -var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString; - -// `%TypedArray%.prototype.toString` method -// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring -exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD); - - -/***/ }), -/* 131 */ -/***/ (function(module, exports, __webpack_require__) { - -var global = __webpack_require__(4); -var DOMIterables = __webpack_require__(132); -var forEach = __webpack_require__(47); -var createNonEnumerableProperty = __webpack_require__(20); - -for (var COLLECTION_NAME in DOMIterables) { - var Collection = global[COLLECTION_NAME]; - var CollectionPrototype = Collection && Collection.prototype; - // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { - createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); - } catch (error) { - CollectionPrototype.forEach = forEach; - } -} - - -/***/ }), -/* 132 */ -/***/ (function(module, exports) { - -// iterable DOM collections -// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods -module.exports = { - CSSRuleList: 0, - CSSStyleDeclaration: 0, - CSSValueList: 0, - ClientRectList: 0, - DOMRectList: 0, - DOMStringList: 0, - DOMTokenList: 1, - DataTransferItemList: 0, - FileList: 0, - HTMLAllCollection: 0, - HTMLCollection: 0, - HTMLFormElement: 0, - HTMLSelectElement: 0, - MediaList: 0, - MimeTypeArray: 0, - NamedNodeMap: 0, - NodeList: 1, - PaintRequestList: 0, - Plugin: 0, - PluginArray: 0, - SVGLengthList: 0, - SVGNumberList: 0, - SVGPathSegList: 0, - SVGPointList: 0, - SVGStringList: 0, - SVGTransformList: 0, - SourceBufferList: 0, - StyleSheetList: 0, - TextTrackCueList: 0, - TextTrackList: 0, - TouchList: 0 -}; - - -/***/ }), -/* 133 */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -/** - * Takes in array of names of errors and returns an object mapping those names to error functions that take in one parameter that is used as the message for the error - * @param names {[]} - * @returns {{name1: function(message),...}} - * @constructor - */ - -__webpack_require__(2); - -__webpack_require__(134); - -__webpack_require__(135); - -__webpack_require__(131); - -function CustomErrors(names) { - var errors = {}; - names.forEach(function (name) { - var CustomError = function CustomError(message) { - var temp = Error.apply(this, arguments); - temp.name = this.name = name; - this.stack = temp.stack; - this.message = temp.message; - this.name = name; - this.message = message; - }; - - CustomError.prototype = Object.create(Error.prototype, { - constructor: { - value: CustomError, - writable: true, - configurable: true - } - }); - errors[name] = CustomError; - }); - return errors; -} - -module.exports = CustomErrors(['NotImplemented', 'InvalidDelta']); - -/***/ }), -/* 134 */ -/***/ (function(module, exports, __webpack_require__) { - -var DESCRIPTORS = __webpack_require__(7); -var defineProperty = __webpack_require__(21).f; - -var FunctionPrototype = Function.prototype; -var FunctionPrototypeToString = FunctionPrototype.toString; -var nameRE = /^\s*function ([^ (]*)/; -var NAME = 'name'; - -// Function instances `.name` property -// https://tc39.github.io/ecma262/#sec-function-instances-name -if (DESCRIPTORS && !(NAME in FunctionPrototype)) { - defineProperty(FunctionPrototype, NAME, { - configurable: true, - get: function () { - try { - return FunctionPrototypeToString.call(this).match(nameRE)[1]; - } catch (error) { - return ''; - } - } - }); -} - - -/***/ }), -/* 135 */ +/* 136 */ /***/ (function(module, exports, __webpack_require__) { -var $ = __webpack_require__(3); -var DESCRIPTORS = __webpack_require__(7); -var create = __webpack_require__(61); +"use strict"; -// `Object.create` method -// https://tc39.github.io/ecma262/#sec-object.create -$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { - create: create +var ArrayBufferViewCore = __webpack_require__(110); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $sort = [].sort; + +// `%TypedArray%.prototype.sort` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort +exportTypedArrayMethod('sort', function sort(comparefn) { + return $sort.call(aTypedArray(this), comparefn); }); /***/ }), -/* 136 */ +/* 137 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; +var ArrayBufferViewCore = __webpack_require__(110); +var toLength = __webpack_require__(40); +var toAbsoluteIndex = __webpack_require__(42); +var speciesConstructor = __webpack_require__(106); -__webpack_require__(137); +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; -__webpack_require__(141); +// `%TypedArray%.prototype.subarray` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray +exportTypedArrayMethod('subarray', function subarray(begin, end) { + var O = aTypedArray(this); + var length = O.length; + var beginIndex = toAbsoluteIndex(begin, length); + return new (speciesConstructor(O, O.constructor))( + O.buffer, + O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, + toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) + ); +}); -__webpack_require__(142); -__webpack_require__(143); +/***/ }), +/* 138 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(59); +"use strict"; -__webpack_require__(81); +var global = __webpack_require__(3); +var ArrayBufferViewCore = __webpack_require__(110); +var fails = __webpack_require__(7); -__webpack_require__(90); +var Int8Array = global.Int8Array; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $toLocaleString = [].toLocaleString; +var $slice = [].slice; -__webpack_require__(144); +// iOS Safari 6.x fails here +var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () { + $toLocaleString.call(new Int8Array(1)); +}); -__webpack_require__(146); +var FORCED = fails(function () { + return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString(); +}) || !fails(function () { + Int8Array.prototype.toLocaleString.call([1, 2]); +}); -__webpack_require__(147); +// `%TypedArray%.prototype.toLocaleString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring +exportTypedArrayMethod('toLocaleString', function toLocaleString() { + return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments); +}, FORCED); -__webpack_require__(148); -__webpack_require__(149); +/***/ }), +/* 139 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(150); +"use strict"; -__webpack_require__(94); +var exportTypedArrayMethod = __webpack_require__(110).exportTypedArrayMethod; +var fails = __webpack_require__(7); +var global = __webpack_require__(3); -__webpack_require__(151); +var Uint8Array = global.Uint8Array; +var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {}; +var arrayToString = [].toString; +var arrayJoin = [].join; -__webpack_require__(152); +if (fails(function () { arrayToString.call({}); })) { + arrayToString = function toString() { + return arrayJoin.call(this); + }; +} -__webpack_require__(153); +var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString; -__webpack_require__(106); +// `%TypedArray%.prototype.toString` method +// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring +exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD); -__webpack_require__(108); -__webpack_require__(109); +/***/ }), +/* 140 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(110); +"use strict"; -__webpack_require__(111); +var $ = __webpack_require__(2); +var isObject = __webpack_require__(15); +var isArray = __webpack_require__(92); +var toAbsoluteIndex = __webpack_require__(42); +var toLength = __webpack_require__(40); +var toIndexedObject = __webpack_require__(10); +var createProperty = __webpack_require__(141); +var wellKnownSymbol = __webpack_require__(50); +var arrayMethodHasSpeciesSupport = __webpack_require__(142); +var arrayMethodUsesToLength = __webpack_require__(97); -__webpack_require__(112); +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice'); +var USES_TO_LENGTH = arrayMethodUsesToLength('slice', { ACCESSORS: true, 0: 0, 1: 2 }); -__webpack_require__(113); +var SPECIES = wellKnownSymbol('species'); +var nativeSlice = [].slice; +var max = Math.max; -__webpack_require__(114); +// `Array.prototype.slice` method +// https://tc39.github.io/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { + slice: function slice(start, end) { + var O = toIndexedObject(this); + var length = toLength(O.length); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject(Constructor)) { + Constructor = Constructor[SPECIES]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === Array || Constructor === undefined) { + return nativeSlice.call(O, k, fin); + } + } + result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + result.length = n; + return result; + } +}); -__webpack_require__(115); -__webpack_require__(116); +/***/ }), +/* 141 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(117); +"use strict"; -__webpack_require__(118); +var toPrimitive = __webpack_require__(14); +var definePropertyModule = __webpack_require__(20); +var createPropertyDescriptor = __webpack_require__(9); -__webpack_require__(120); +module.exports = function (object, key, value) { + var propertyKey = toPrimitive(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; -__webpack_require__(121); -__webpack_require__(122); +/***/ }), +/* 142 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(123); +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(50); +var V8_VERSION = __webpack_require__(143); -__webpack_require__(124); +var SPECIES = wellKnownSymbol('species'); -__webpack_require__(125); +module.exports = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; -__webpack_require__(126); -__webpack_require__(127); +/***/ }), +/* 143 */ +/***/ (function(module, exports, __webpack_require__) { -__webpack_require__(128); +var global = __webpack_require__(3); +var userAgent = __webpack_require__(144); -__webpack_require__(129); +var process = global.process; +var versions = process && process.versions; +var v8 = versions && versions.v8; +var match, version; -__webpack_require__(130); +if (v8) { + match = v8.split('.'); + version = match[0] + match[1]; +} else if (userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) version = match[1]; + } +} -__webpack_require__(154); +module.exports = version && +version; -function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } -function uint8ArrayToString(uintArray) { - var encodedString = String.fromCharCode.apply(null, uintArray); - var decodedString = decodeURIComponent(escape(encodedString)); - return decodedString; -} +/***/ }), +/* 144 */ +/***/ (function(module, exports, __webpack_require__) { -function stringToUint8Array(str) { - var buf = new Uint8Array(str.length); +var getBuiltIn = __webpack_require__(35); - for (var i = 0, strLen = str.length; i < strLen; i++) { - buf[i] = str.charCodeAt(i); - } +module.exports = getBuiltIn('navigator', 'userAgent') || ''; - return buf; -} -function equal(typedArray1, typedArray2) { - if (typedArray1.length !== typedArray2.length) { - return false; - } +/***/ }), +/* 145 */ +/***/ (function(module, exports, __webpack_require__) { - for (var i = 0; i < typedArray1.length; i++) { - if (typedArray1[i] !== typedArray2[i]) { - return false; - } - } +"use strict"; - return true; -} +var $ = __webpack_require__(2); +var forEach = __webpack_require__(146); -function TypedArrayList() { - this.typedArrays = []; - this.startIndexes = []; - this.length = 0; -} +// `Array.prototype.forEach` method +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +$({ target: 'Array', proto: true, forced: [].forEach != forEach }, { + forEach: forEach +}); -TypedArrayList.prototype.add = function (typedArray) { - var typedArrayTypes = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; - var matchingTypedArrayTypes = typedArrayTypes.filter(function (typedArrayType) { - return typedArray instanceof typedArrayType; - }); - if (matchingTypedArrayTypes.length < 1) { - throw Error('Given ' + _typeof(typedArray) + ' when expected a TypedArray'); - } +/***/ }), +/* 146 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; - var startIndex; +var $forEach = __webpack_require__(90).forEach; +var arrayMethodIsStrict = __webpack_require__(96); +var arrayMethodUsesToLength = __webpack_require__(97); - if (this.typedArrays.length === 0) { - startIndex = 0; - } else { - var lastIndex = this.startIndexes.length - 1; - var lastStartIndex = this.startIndexes[lastIndex]; - var lastLength = this.typedArrays[lastIndex].length; - startIndex = lastStartIndex + lastLength; +var STRICT_METHOD = arrayMethodIsStrict('forEach'); +var USES_TO_LENGTH = arrayMethodUsesToLength('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.github.io/ecma262/#sec-array.prototype.foreach +module.exports = (!STRICT_METHOD || !USES_TO_LENGTH) ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +} : [].forEach; + + +/***/ }), +/* 147 */ +/***/ (function(module, exports, __webpack_require__) { + +var global = __webpack_require__(3); +var DOMIterables = __webpack_require__(70); +var forEach = __webpack_require__(146); +var createNonEnumerableProperty = __webpack_require__(19); + +for (var COLLECTION_NAME in DOMIterables) { + var Collection = global[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; } +} - this.startIndexes.push(startIndex); - this.typedArrays.push(typedArray); - this.length += startIndex + typedArray.length; -}; -TypedArrayList.prototype.get = function (index) { - var listIndex = getIndex(this.startIndexes, index); - var typedArray = index - this.startIndexes[listIndex]; - return this.typedArrays[listIndex][typedArray]; -}; +/***/ }), +/* 148 */ +/***/ (function(module, exports, __webpack_require__) { + +var defineWellKnownSymbol = __webpack_require__(48); -TypedArrayList.prototype.set = function (index, value) { - if (typeof index !== 'number' || isNaN(index)) { - throw new Error('Given non-number index: ' + index); - } //console.log(index); +// `Symbol.toPrimitive` well-known symbol +// https://tc39.github.io/ecma262/#sec-symbol.toprimitive +defineWellKnownSymbol('toPrimitive'); + + +/***/ }), +/* 149 */ +/***/ (function(module, exports, __webpack_require__) { +var createNonEnumerableProperty = __webpack_require__(19); +var dateToPrimitive = __webpack_require__(150); +var wellKnownSymbol = __webpack_require__(50); - var listIndex = getIndex(this.startIndexes, index); - var typedArrayIndex = index - this.startIndexes[listIndex]; - this.typedArrays[listIndex][typedArrayIndex] = value; -}; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var DatePrototype = Date.prototype; -function getIndex(arr, element) { - // Performance optimization for most common case - if (arr.length === 2) { - return element < arr[1] ? 0 : 1; - } +// `Date.prototype[@@toPrimitive]` method +// https://tc39.github.io/ecma262/#sec-date.prototype-@@toprimitive +if (!(TO_PRIMITIVE in DatePrototype)) { + createNonEnumerableProperty(DatePrototype, TO_PRIMITIVE, dateToPrimitive); +} - var low = 0; - var high = arr.length - 1; - while (low < high) { - var mid = Math.floor((low + high) / 2); +/***/ }), +/* 150 */ +/***/ (function(module, exports, __webpack_require__) { - if (arr[mid] === element) { - return mid; - } else if (arr[mid] < element) { - low = mid + 1; - } else { - high = mid - 1; - } - } +"use strict"; - if (arr[high] > element) { - return high - 1; - } else { - return high; - } -} +var anObject = __webpack_require__(21); +var toPrimitive = __webpack_require__(14); -module.exports = { - uint8ArrayToString: uint8ArrayToString, - stringToUint8Array: stringToUint8Array, - equal: equal, - TypedArrayList: TypedArrayList +module.exports = function (hint) { + if (hint !== 'string' && hint !== 'number' && hint !== 'default') { + throw TypeError('Incorrect hint'); + } return toPrimitive(anObject(this), hint !== 'number'); }; + /***/ }), -/* 137 */ +/* 151 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var $ = __webpack_require__(3); -var global = __webpack_require__(4); -var getBuiltIn = __webpack_require__(36); -var IS_PURE = __webpack_require__(31); -var DESCRIPTORS = __webpack_require__(7); -var NATIVE_SYMBOL = __webpack_require__(55); -var USE_SYMBOL_AS_UID = __webpack_require__(56); -var fails = __webpack_require__(8); -var has = __webpack_require__(17); -var isArray = __webpack_require__(53); -var isObject = __webpack_require__(16); -var anObject = __webpack_require__(22); -var toObject = __webpack_require__(51); -var toIndexedObject = __webpack_require__(11); -var toPrimitive = __webpack_require__(15); -var createPropertyDescriptor = __webpack_require__(10); +var $ = __webpack_require__(2); +var global = __webpack_require__(3); +var getBuiltIn = __webpack_require__(35); +var IS_PURE = __webpack_require__(30); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_SYMBOL = __webpack_require__(51); +var USE_SYMBOL_AS_UID = __webpack_require__(52); +var fails = __webpack_require__(7); +var has = __webpack_require__(16); +var isArray = __webpack_require__(92); +var isObject = __webpack_require__(15); +var anObject = __webpack_require__(21); +var toObject = __webpack_require__(59); +var toIndexedObject = __webpack_require__(10); +var toPrimitive = __webpack_require__(14); +var createPropertyDescriptor = __webpack_require__(9); var nativeObjectCreate = __webpack_require__(61); var objectKeys = __webpack_require__(63); -var getOwnPropertyNamesModule = __webpack_require__(38); -var getOwnPropertyNamesExternal = __webpack_require__(138); -var getOwnPropertySymbolsModule = __webpack_require__(45); -var getOwnPropertyDescriptorModule = __webpack_require__(6); -var definePropertyModule = __webpack_require__(21); -var propertyIsEnumerableModule = __webpack_require__(9); -var createNonEnumerableProperty = __webpack_require__(20); -var redefine = __webpack_require__(23); -var shared = __webpack_require__(30); -var sharedKey = __webpack_require__(29); -var hiddenKeys = __webpack_require__(33); -var uid = __webpack_require__(32); -var wellKnownSymbol = __webpack_require__(54); -var wrappedWellKnownSymbolModule = __webpack_require__(139); -var defineWellKnownSymbol = __webpack_require__(140); -var setToStringTag = __webpack_require__(71); -var InternalStateModule = __webpack_require__(27); -var $forEach = __webpack_require__(48).forEach; +var getOwnPropertyNamesModule = __webpack_require__(37); +var getOwnPropertyNamesExternal = __webpack_require__(152); +var getOwnPropertySymbolsModule = __webpack_require__(44); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(20); +var propertyIsEnumerableModule = __webpack_require__(8); +var createNonEnumerableProperty = __webpack_require__(19); +var redefine = __webpack_require__(22); +var shared = __webpack_require__(29); +var sharedKey = __webpack_require__(28); +var hiddenKeys = __webpack_require__(32); +var uid = __webpack_require__(31); +var wellKnownSymbol = __webpack_require__(50); +var wrappedWellKnownSymbolModule = __webpack_require__(49); +var defineWellKnownSymbol = __webpack_require__(48); +var setToStringTag = __webpack_require__(65); +var InternalStateModule = __webpack_require__(26); +var $forEach = __webpack_require__(90).forEach; var HIDDEN = sharedKey('hidden'); var SYMBOL = 'Symbol'; @@ -4632,11 +5002,11 @@ hiddenKeys[HIDDEN] = true; /***/ }), -/* 138 */ +/* 152 */ /***/ (function(module, exports, __webpack_require__) { -var toIndexedObject = __webpack_require__(11); -var nativeGetOwnPropertyNames = __webpack_require__(38).f; +var toIndexedObject = __webpack_require__(10); +var nativeGetOwnPropertyNames = __webpack_require__(37).f; var toString = {}.toString; @@ -4660,46 +5030,20 @@ module.exports.f = function getOwnPropertyNames(it) { /***/ }), -/* 139 */ -/***/ (function(module, exports, __webpack_require__) { - -var wellKnownSymbol = __webpack_require__(54); - -exports.f = wellKnownSymbol; - - -/***/ }), -/* 140 */ -/***/ (function(module, exports, __webpack_require__) { - -var path = __webpack_require__(37); -var has = __webpack_require__(17); -var wrappedWellKnownSymbolModule = __webpack_require__(139); -var defineProperty = __webpack_require__(21).f; - -module.exports = function (NAME) { - var Symbol = path.Symbol || (path.Symbol = {}); - if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, { - value: wrappedWellKnownSymbolModule.f(NAME) - }); -}; - - -/***/ }), -/* 141 */ +/* 153 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; // `Symbol.prototype.description` getter // https://tc39.github.io/ecma262/#sec-symbol.prototype.description -var $ = __webpack_require__(3); -var DESCRIPTORS = __webpack_require__(7); -var global = __webpack_require__(4); -var has = __webpack_require__(17); -var isObject = __webpack_require__(16); -var defineProperty = __webpack_require__(21).f; -var copyConstructorProperties = __webpack_require__(34); +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var has = __webpack_require__(16); +var isObject = __webpack_require__(15); +var defineProperty = __webpack_require__(20).f; +var copyConstructorProperties = __webpack_require__(33); var NativeSymbol = global.Symbol; @@ -4743,175 +5087,452 @@ if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in Nati /***/ }), -/* 142 */ +/* 154 */ /***/ (function(module, exports, __webpack_require__) { -var defineWellKnownSymbol = __webpack_require__(140); +"use strict"; -// `Symbol.iterator` well-known symbol -// https://tc39.github.io/ecma262/#sec-symbol.iterator -defineWellKnownSymbol('iterator'); +var DESCRIPTORS = __webpack_require__(6); +var global = __webpack_require__(3); +var isForced = __webpack_require__(45); +var redefine = __webpack_require__(22); +var has = __webpack_require__(16); +var classof = __webpack_require__(12); +var inheritIfRequired = __webpack_require__(88); +var toPrimitive = __webpack_require__(14); +var fails = __webpack_require__(7); +var create = __webpack_require__(61); +var getOwnPropertyNames = __webpack_require__(37).f; +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var defineProperty = __webpack_require__(20).f; +var trim = __webpack_require__(155).trim; + +var NUMBER = 'Number'; +var NativeNumber = global[NUMBER]; +var NumberPrototype = NativeNumber.prototype; + +// Opera ~12 has broken Object#toString +var BROKEN_CLASSOF = classof(create(NumberPrototype)) == NUMBER; + +// `ToNumber` abstract operation +// https://tc39.github.io/ecma262/#sec-tonumber +var toNumber = function (argument) { + var it = toPrimitive(argument, false); + var first, third, radix, maxCode, digits, length, index, code; + if (typeof it == 'string' && it.length > 2) { + it = trim(it); + first = it.charCodeAt(0); + if (first === 43 || first === 45) { + third = it.charCodeAt(2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (it.charCodeAt(1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i + default: return +it; + } + digits = it.slice(2); + length = digits.length; + for (index = 0; index < length; index++) { + code = digits.charCodeAt(index); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; +}; + +// `Number` constructor +// https://tc39.github.io/ecma262/#sec-number-constructor +if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { + var NumberWrapper = function Number(value) { + var it = arguments.length < 1 ? 0 : value; + var dummy = this; + return dummy instanceof NumberWrapper + // check on 1..constructor(foo) case + && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classof(dummy) != NUMBER) + ? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it); + }; + for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger' + ).split(','), j = 0, key; keys.length > j; j++) { + if (has(NativeNumber, key = keys[j]) && !has(NumberWrapper, key)) { + defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key)); + } + } + NumberWrapper.prototype = NumberPrototype; + NumberPrototype.constructor = NumberWrapper; + redefine(global, NUMBER, NumberWrapper); +} /***/ }), -/* 143 */ +/* 155 */ /***/ (function(module, exports, __webpack_require__) { -"use strict"; +var requireObjectCoercible = __webpack_require__(13); +var whitespaces = __webpack_require__(156); -var $ = __webpack_require__(3); -var $filter = __webpack_require__(48).filter; -var arrayMethodHasSpeciesSupport = __webpack_require__(78); -var arrayMethodUsesToLength = __webpack_require__(58); +var whitespace = '[' + whitespaces + ']'; +var ltrim = RegExp('^' + whitespace + whitespace + '*'); +var rtrim = RegExp(whitespace + whitespace + '*$'); -var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); -// Edge 14- issue -var USES_TO_LENGTH = arrayMethodUsesToLength('filter'); +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = String(requireObjectCoercible($this)); + if (TYPE & 1) string = string.replace(ltrim, ''); + if (TYPE & 2) string = string.replace(rtrim, ''); + return string; + }; +}; -// `Array.prototype.filter` method -// https://tc39.github.io/ecma262/#sec-array.prototype.filter -// with adding support of @@species -$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { - filter: function filter(callbackfn /* , thisArg */) { - return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); - } -}); +module.exports = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.github.io/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.github.io/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; /***/ }), -/* 144 */ +/* 156 */ +/***/ (function(module, exports) { + +// a string of all valid unicode whitespaces +// eslint-disable-next-line max-len +module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + +/***/ }), +/* 157 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var charAt = __webpack_require__(145).charAt; -var InternalStateModule = __webpack_require__(27); -var defineIterator = __webpack_require__(66); -var STRING_ITERATOR = 'String Iterator'; -var setInternalState = InternalStateModule.set; -var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); +/** + * Takes in array of names of errors and returns an object mapping those names to error functions that take in one parameter that is used as the message for the error + * @param names {[]} + * @returns {{name1: function(message),...}} + * @constructor + */ +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(145); +__webpack_require__(98); +__webpack_require__(147); +__webpack_require__(158); +__webpack_require__(159); +function CustomErrors(names) { + var errors = {}; + names.forEach(function (name) { + var CustomError = function CustomError(message) { + var temp = Error.apply(this, arguments); + temp.name = this.name = name; + this.stack = temp.stack; + this.message = temp.message; + this.name = name; + this.message = message; + }; + CustomError.prototype = Object.create(Error.prototype, { + constructor: { + value: CustomError, + writable: true, + configurable: true + } + }); + errors[name] = CustomError; + }); + return errors; +} +var _default = exports["default"] = /* @__PURE__ */CustomErrors(['NotImplemented', 'InvalidDelta']); -// `String.prototype[@@iterator]` method -// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator -defineIterator(String, 'String', function (iterated) { - setInternalState(this, { - type: STRING_ITERATOR, - string: String(iterated), - index: 0 +/***/ }), +/* 158 */ +/***/ (function(module, exports, __webpack_require__) { + +var DESCRIPTORS = __webpack_require__(6); +var defineProperty = __webpack_require__(20).f; + +var FunctionPrototype = Function.prototype; +var FunctionPrototypeToString = FunctionPrototype.toString; +var nameRE = /^\s*function ([^ (]*)/; +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.github.io/ecma262/#sec-function-instances-name +if (DESCRIPTORS && !(NAME in FunctionPrototype)) { + defineProperty(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return FunctionPrototypeToString.call(this).match(nameRE)[1]; + } catch (error) { + return ''; + } + } }); -// `%StringIteratorPrototype%.next` method -// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next -}, function next() { - var state = getInternalState(this); - var string = state.string; - var index = state.index; - var point; - if (index >= string.length) return { value: undefined, done: true }; - point = charAt(string, index); - state.index += point.length; - return { value: point, done: false }; +} + + +/***/ }), +/* 159 */ +/***/ (function(module, exports, __webpack_require__) { + +var $ = __webpack_require__(2); +var DESCRIPTORS = __webpack_require__(6); +var create = __webpack_require__(61); + +// `Object.create` method +// https://tc39.github.io/ecma262/#sec-object.create +$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { + create: create }); /***/ }), -/* 145 */ +/* 160 */ /***/ (function(module, exports, __webpack_require__) { -var toInteger = __webpack_require__(42); -var requireObjectCoercible = __webpack_require__(14); +"use strict"; -// `String.prototype.{ codePointAt, at }` methods implementation -var createMethod = function (CONVERT_TO_STRING) { - return function ($this, pos) { - var S = String(requireObjectCoercible($this)); - var position = toInteger(pos); - var size = S.length; - var first, second; - if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; - first = S.charCodeAt(position); - return first < 0xD800 || first > 0xDBFF || position + 1 === size - || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF - ? CONVERT_TO_STRING ? S.charAt(position) : first - : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; - }; -}; -module.exports = { - // `String.prototype.codePointAt` method - // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat - codeAt: createMethod(false), - // `String.prototype.at` method - // https://github.com/mathiasbynens/String.prototype.at - charAt: createMethod(true) -}; +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(154); +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.TypedArrayList = void 0; +exports.equal = equal; +exports.stringToUint8Array = stringToUint8Array; +exports.uint8ArrayToString = uint8ArrayToString; +__webpack_require__(71); +__webpack_require__(100); +__webpack_require__(98); +__webpack_require__(107); +__webpack_require__(115); +__webpack_require__(117); +__webpack_require__(118); +__webpack_require__(119); +__webpack_require__(120); +__webpack_require__(121); +__webpack_require__(122); +__webpack_require__(123); +__webpack_require__(124); +__webpack_require__(125); +__webpack_require__(126); +__webpack_require__(127); +__webpack_require__(129); +__webpack_require__(130); +__webpack_require__(131); +__webpack_require__(132); +__webpack_require__(133); +__webpack_require__(134); +__webpack_require__(135); +__webpack_require__(136); +__webpack_require__(137); +__webpack_require__(138); +__webpack_require__(139); +__webpack_require__(161); +__webpack_require__(162); +__webpack_require__(163); +__webpack_require__(164); +__webpack_require__(165); +__webpack_require__(166); +__webpack_require__(167); +__webpack_require__(168); +__webpack_require__(169); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function uint8ArrayToString(uintArray) { + var encodedString = String.fromCharCode.apply(null, uintArray); + var decodedString = decodeURIComponent(escape(encodedString)); + return decodedString; +} +function stringToUint8Array(str) { + var buf = new Uint8Array(str.length); + for (var i = 0, strLen = str.length; i < strLen; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; +} +function equal(typedArray1, typedArray2) { + if (typedArray1.length !== typedArray2.length) { + return false; + } + for (var i = 0; i < typedArray1.length; i++) { + if (typedArray1[i] !== typedArray2[i]) { + return false; + } + } + return true; +} +var TypedArrayList = exports.TypedArrayList = /*#__PURE__*/function () { + function TypedArrayList() { + _classCallCheck(this, TypedArrayList); + this.typedArrays = []; + this.startIndexes = []; + this.length = 0; + } + _createClass(TypedArrayList, [{ + key: "add", + value: function add(typedArray) { + var typedArrayTypes = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; + var matchingTypedArrayTypes = typedArrayTypes.filter(function (typedArrayType) { + return typedArray instanceof typedArrayType; + }); + if (matchingTypedArrayTypes.length < 1) { + throw Error('Given ' + _typeof(typedArray) + ' when expected a TypedArray'); + } + var startIndex; + if (this.typedArrays.length === 0) { + startIndex = 0; + } else { + var lastIndex = this.startIndexes.length - 1; + var lastStartIndex = this.startIndexes[lastIndex]; + var lastLength = this.typedArrays[lastIndex].length; + startIndex = lastStartIndex + lastLength; + } + this.startIndexes.push(startIndex); + this.typedArrays.push(typedArray); + this.length += startIndex + typedArray.length; + } + }, { + key: "get", + value: function get(index) { + var listIndex = getIndex(this.startIndexes, index); + var typedArray = index - this.startIndexes[listIndex]; + return this.typedArrays[listIndex][typedArray]; + } + }, { + key: "set", + value: function set(index, value) { + if (typeof index !== 'number' || isNaN(index)) { + throw new Error('Given non-number index: ' + index); + } + //console.log(index); + var listIndex = getIndex(this.startIndexes, index); + var typedArrayIndex = index - this.startIndexes[listIndex]; + this.typedArrays[listIndex][typedArrayIndex] = value; + } + }]); + return TypedArrayList; +}(); +function getIndex(arr, element) { + // Performance optimization for most common case + if (arr.length === 2) { + return element < arr[1] ? 0 : 1; + } + var low = 0; + var high = arr.length - 1; + while (low < high) { + var mid = Math.floor((low + high) / 2); + if (arr[mid] === element) { + return mid; + } else if (arr[mid] < element) { + low = mid + 1; + } else { + high = mid - 1; + } + } + if (arr[high] > element) { + return high - 1; + } else { + return high; + } +} /***/ }), -/* 146 */ +/* 161 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Float32Array` constructor +// `Int8Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Float32', function (init) { - return function Float32Array(data, byteOffset, length) { +createTypedArrayConstructor('Int8', function (init) { + return function Int8Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); /***/ }), -/* 147 */ +/* 162 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Float64Array` constructor +// `Uint8ClampedArray` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Float64', function (init) { - return function Float64Array(data, byteOffset, length) { +createTypedArrayConstructor('Uint8', function (init) { + return function Uint8ClampedArray(data, byteOffset, length) { return init(this, data, byteOffset, length); }; -}); +}, true); /***/ }), -/* 148 */ +/* 163 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Int8Array` constructor +// `Int16Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Int8', function (init) { - return function Int8Array(data, byteOffset, length) { +createTypedArrayConstructor('Int16', function (init) { + return function Int16Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); /***/ }), -/* 149 */ +/* 164 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Int16Array` constructor +// `Uint16Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Int16', function (init) { - return function Int16Array(data, byteOffset, length) { +createTypedArrayConstructor('Uint16', function (init) { + return function Uint16Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); /***/ }), -/* 150 */ +/* 165 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); // `Int32Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects @@ -4923,95 +5544,82 @@ createTypedArrayConstructor('Int32', function (init) { /***/ }), -/* 151 */ +/* 166 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Uint8ClampedArray` constructor +// `Uint32Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Uint8', function (init) { - return function Uint8ClampedArray(data, byteOffset, length) { +createTypedArrayConstructor('Uint32', function (init) { + return function Uint32Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; -}, true); +}); /***/ }), -/* 152 */ +/* 167 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Uint16Array` constructor +// `Float32Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Uint16', function (init) { - return function Uint16Array(data, byteOffset, length) { +createTypedArrayConstructor('Float32', function (init) { + return function Float32Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); /***/ }), -/* 153 */ +/* 168 */ /***/ (function(module, exports, __webpack_require__) { -var createTypedArrayConstructor = __webpack_require__(95); +var createTypedArrayConstructor = __webpack_require__(108); -// `Uint32Array` constructor +// `Float64Array` constructor // https://tc39.github.io/ecma262/#sec-typedarray-objects -createTypedArrayConstructor('Uint32', function (init) { - return function Uint32Array(data, byteOffset, length) { +createTypedArrayConstructor('Float64', function (init) { + return function Float64Array(data, byteOffset, length) { return init(this, data, byteOffset, length); }; }); /***/ }), -/* 154 */ +/* 169 */ /***/ (function(module, exports, __webpack_require__) { -var global = __webpack_require__(4); -var DOMIterables = __webpack_require__(132); -var ArrayIteratorMethods = __webpack_require__(59); -var createNonEnumerableProperty = __webpack_require__(20); -var wellKnownSymbol = __webpack_require__(54); +"use strict"; -var ITERATOR = wellKnownSymbol('iterator'); -var TO_STRING_TAG = wellKnownSymbol('toStringTag'); -var ArrayValues = ArrayIteratorMethods.values; +var $ = __webpack_require__(2); +var $filter = __webpack_require__(90).filter; +var arrayMethodHasSpeciesSupport = __webpack_require__(142); +var arrayMethodUsesToLength = __webpack_require__(97); -for (var COLLECTION_NAME in DOMIterables) { - var Collection = global[COLLECTION_NAME]; - var CollectionPrototype = Collection && Collection.prototype; - if (CollectionPrototype) { - // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype[ITERATOR] !== ArrayValues) try { - createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); - } catch (error) { - CollectionPrototype[ITERATOR] = ArrayValues; - } - if (!CollectionPrototype[TO_STRING_TAG]) { - createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); - } - if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { - // some Chrome versions have non-configurable methods on DOMTokenList - if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { - createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); - } catch (error) { - CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; - } - } +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); +// Edge 14- issue +var USES_TO_LENGTH = arrayMethodUsesToLength('filter'); + +// `Array.prototype.filter` method +// https://tc39.github.io/ecma262/#sec-array.prototype.filter +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); } -} +}); /***/ }), -/* 155 */ +/* 170 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; + /** * Converts RFC 3284 definition of integer in buffer to decimal * Also returns the index of the byte after the integer @@ -5019,78 +5627,72 @@ for (var COLLECTION_NAME in DOMIterables) { * @param position {Number} * @returns {{position: {Number}, value: {Number}}} */ - +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = integer; function integer(buffer, position) { var result = { position: position, value: 0 }; - do { /* Shift the existing value left for 7 bits (base127 conversion) and merge it with the next value without its highest bit */ result.value = result.value << 7 | buffer[result.position] & 127; - /* Avoid Number overflows */ + /* Avoid Number overflows */ if (result.value < 0) { throw new Error('RFC 3284 Integer conversion: Buffer overflow'); } } while (buffer[result.position++] & 128); - return result; } -module.exports = integer; - /***/ }), -/* 156 */ +/* 171 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -__webpack_require__(76); - -var errors = __webpack_require__(133); - -var deserializeInteger = __webpack_require__(155); - -var tokenizeInstructions = __webpack_require__(157); - +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = delta; +__webpack_require__(140); +var _errors = _interopRequireDefault(__webpack_require__(157)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var _tokenize_instructions = _interopRequireDefault(__webpack_require__(172)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function delta(delta, position) { - var targetWindowLength, dataLength, instructionsLength, addressesLength; // parentheses are needed for assignment destructuring - - var _deserializeInteger = deserializeInteger(delta, position); + var targetWindowLength, dataLength, instructionsLength, addressesLength; + // parentheses are needed for assignment destructuring + // Delta_Indicator byte + var _deserializeInteger = (0, _integer["default"])(delta, position); targetWindowLength = _deserializeInteger.value; position = _deserializeInteger.position; - - // Delta_Indicator byte if (delta[position] !== 0) { - throw new errors.NotImplemented('VCD_DECOMPRESS is not supported, Delta_Indicator must be zero at byte ' + position + ' and not ' + delta[position]); + throw new _errors["default"].NotImplemented('VCD_DECOMPRESS is not supported, Delta_Indicator must be zero at byte ' + position + ' and not ' + delta[position]); } - position++; - - var _deserializeInteger2 = deserializeInteger(delta, position); - + var _deserializeInteger2 = (0, _integer["default"])(delta, position); dataLength = _deserializeInteger2.value; position = _deserializeInteger2.position; - - var _deserializeInteger3 = deserializeInteger(delta, position); - + var _deserializeInteger3 = (0, _integer["default"])(delta, position); instructionsLength = _deserializeInteger3.value; position = _deserializeInteger3.position; - - var _deserializeInteger4 = deserializeInteger(delta, position); - + var _deserializeInteger4 = (0, _integer["default"])(delta, position); addressesLength = _deserializeInteger4.value; position = _deserializeInteger4.position; var dataNextPosition = position + dataLength; var data = delta.slice(position, dataNextPosition); var instructionsNextPosition = dataNextPosition + instructionsLength; var instructions = delta.slice(dataNextPosition, instructionsNextPosition); - var deserializedInstructions = tokenizeInstructions(instructions); + var deserializedInstructions = (0, _tokenize_instructions["default"])(instructions); var addressesNextPosition = instructionsNextPosition + addressesLength; var addresses = delta.slice(instructionsNextPosition, addressesNextPosition); position = addressesNextPosition; @@ -5104,186 +5706,169 @@ function delta(delta, position) { return window; } -module.exports = delta; - /***/ }), -/* 157 */ +/* 172 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var instructions = __webpack_require__(158); - -var deserializeInteger = __webpack_require__(155); - +__webpack_require__(1); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = tokenizeInstructions; +var _instructions = _interopRequireDefault(__webpack_require__(173)); +var _integer = _interopRequireDefault(__webpack_require__(170)); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function tokenizeInstructions(instructionsBuffer) { var deserializedInstructions = []; var instructionsPosition = 0; - while (instructionsPosition < instructionsBuffer.length) { var index = instructionsBuffer[instructionsPosition++]; var addSize = void 0, - copySize = void 0, - size = void 0; - + copySize = void 0, + size = void 0; if (index === 0) { - var _deserializeInteger = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger.value; instructionsPosition = _deserializeInteger.position; - deserializedInstructions.push(new instructions.RUN(size)); + deserializedInstructions.push(new _instructions["default"].RUN(size)); } else if (index === 1) { - var _deserializeInteger2 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger2 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger2.value; instructionsPosition = _deserializeInteger2.position; - deserializedInstructions.push(new instructions.ADD(size)); + deserializedInstructions.push(new _instructions["default"].ADD(size)); } else if (index < 19) { - deserializedInstructions.push(new instructions.ADD(index - 1)); + deserializedInstructions.push(new _instructions["default"].ADD(index - 1)); } else if (index === 19) { - var _deserializeInteger3 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger3 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger3.value; instructionsPosition = _deserializeInteger3.position; - deserializedInstructions.push(new instructions.COPY(size, 0)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 0)); } else if (index < 35) { - deserializedInstructions.push(new instructions.COPY(index - 16, 0)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 16, 0)); } else if (index === 35) { - var _deserializeInteger4 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger4 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger4.value; instructionsPosition = _deserializeInteger4.position; - deserializedInstructions.push(new instructions.COPY(size, 1)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 1)); } else if (index < 51) { - deserializedInstructions.push(new instructions.COPY(index - 32, 1)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 32, 1)); } else if (index === 51) { - var _deserializeInteger5 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger5 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger5.value; instructionsPosition = _deserializeInteger5.position; - deserializedInstructions.push(new instructions.COPY(size, 2)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 2)); } else if (index < 67) { - deserializedInstructions.push(new instructions.COPY(index - 48, 2)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 48, 2)); } else if (index === 67) { - var _deserializeInteger6 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger6 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger6.value; instructionsPosition = _deserializeInteger6.position; - deserializedInstructions.push(new instructions.COPY(size, 3)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 3)); } else if (index < 83) { - deserializedInstructions.push(new instructions.COPY(index - 64, 3)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 64, 3)); } else if (index === 83) { - var _deserializeInteger7 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger7 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger7.value; instructionsPosition = _deserializeInteger7.position; - deserializedInstructions.push(new instructions.COPY(size, 4)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 4)); } else if (index < 99) { - deserializedInstructions.push(new instructions.COPY(index - 80, 4)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 80, 4)); } else if (index === 99) { - var _deserializeInteger8 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger8 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger8.value; instructionsPosition = _deserializeInteger8.position; - deserializedInstructions.push(new instructions.COPY(size, 5)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 5)); } else if (index < 115) { - deserializedInstructions.push(new instructions.COPY(index - 96, 5)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 96, 5)); } else if (index === 115) { - var _deserializeInteger9 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger9 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger9.value; instructionsPosition = _deserializeInteger9.position; - deserializedInstructions.push(new instructions.COPY(size, 6)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 6)); } else if (index < 131) { - deserializedInstructions.push(new instructions.COPY(index - 112, 6)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 112, 6)); } else if (index === 131) { - var _deserializeInteger10 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger10 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger10.value; instructionsPosition = _deserializeInteger10.position; - deserializedInstructions.push(new instructions.COPY(size, 7)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 7)); } else if (index < 147) { - deserializedInstructions.push(new instructions.COPY(index - 128, 7)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 128, 7)); } else if (index === 147) { - var _deserializeInteger11 = deserializeInteger(instructionsBuffer, instructionsPosition); - + var _deserializeInteger11 = (0, _integer["default"])(instructionsBuffer, instructionsPosition); size = _deserializeInteger11.value; instructionsPosition = _deserializeInteger11.position; - deserializedInstructions.push(new instructions.COPY(size, 8)); + deserializedInstructions.push(new _instructions["default"].COPY(size, 8)); } else if (index < 163) { - deserializedInstructions.push(new instructions.COPY(index - 144, 8)); + deserializedInstructions.push(new _instructions["default"].COPY(index - 144, 8)); } else if (index < 175) { var _ADD_COPY = ADD_COPY(index, 163); - addSize = _ADD_COPY.addSize; copySize = _ADD_COPY.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 0)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 0)); } else if (index < 187) { var _ADD_COPY2 = ADD_COPY(index, 175); - addSize = _ADD_COPY2.addSize; copySize = _ADD_COPY2.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 1)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 1)); } else if (index < 199) { var _ADD_COPY3 = ADD_COPY(index, 187); - addSize = _ADD_COPY3.addSize; copySize = _ADD_COPY3.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 2)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 2)); } else if (index < 211) { var _ADD_COPY4 = ADD_COPY(index, 199); - addSize = _ADD_COPY4.addSize; copySize = _ADD_COPY4.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 3)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 3)); } else if (index < 223) { var _ADD_COPY5 = ADD_COPY(index, 211); - addSize = _ADD_COPY5.addSize; copySize = _ADD_COPY5.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 4)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 4)); } else if (index < 235) { var _ADD_COPY6 = ADD_COPY(index, 223); - addSize = _ADD_COPY6.addSize; copySize = _ADD_COPY6.copySize; - deserializedInstructions.push(new instructions.ADD(addSize)); - deserializedInstructions.push(new instructions.COPY(copySize, 5)); + deserializedInstructions.push(new _instructions["default"].ADD(addSize)); + deserializedInstructions.push(new _instructions["default"].COPY(copySize, 5)); } else if (index < 239) { - deserializedInstructions.push(new instructions.ADD(index - 235 + 1)); - deserializedInstructions.push(new instructions.COPY(4, 6)); + deserializedInstructions.push(new _instructions["default"].ADD(index - 235 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 6)); } else if (index < 243) { - deserializedInstructions.push(new instructions.ADD(index - 239 + 1)); - deserializedInstructions.push(new instructions.COPY(4, 7)); + deserializedInstructions.push(new _instructions["default"].ADD(index - 239 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 7)); } else if (index < 247) { - deserializedInstructions.push(new instructions.ADD(index - 243 + 1)); - deserializedInstructions.push(new instructions.COPY(4, 8)); + deserializedInstructions.push(new _instructions["default"].ADD(index - 243 + 1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, 8)); } else if (index < 256) { - deserializedInstructions.push(new instructions.COPY(4, index - 247)); - deserializedInstructions.push(new instructions.ADD(1)); + deserializedInstructions.push(new _instructions["default"].COPY(4, index - 247)); + deserializedInstructions.push(new _instructions["default"].ADD(1)); } else { throw new Error('Should not get here'); } } - return deserializedInstructions; } - function ADD_COPY(index, baseIndex) { - var zeroBased = index - baseIndex; // 0,1,2 -> 0 3,4,5 -> 1 etc. - - var addSizeIndex = Math.floor(zeroBased / 3); // offset so size starts at 1 - - var addSize = addSizeIndex + 1; // rotate through 0, 1, and 2 + var zeroBased = index - baseIndex; - var copySizeIndex = zeroBased % 3; // offset so size starts at 4 + // 0,1,2 -> 0 3,4,5 -> 1 etc. + var addSizeIndex = Math.floor(zeroBased / 3); + // offset so size starts at 1 + var addSize = addSizeIndex + 1; + // rotate through 0, 1, and 2 + var copySizeIndex = zeroBased % 3; + // offset so size starts at 4 var copySize = copySizeIndex + 4; return { addSize: addSize, @@ -5291,131 +5876,187 @@ function ADD_COPY(index, baseIndex) { }; } -module.exports = tokenizeInstructions; - /***/ }), -/* 158 */ +/* 173 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -__webpack_require__(134); - -var deserializeInteger = __webpack_require__(155); - -var TypedArray = __webpack_require__(136); - -function ADD(size) { - this.size = size; -} - -function COPY(size, mode) { - this.size = size; - this.mode = mode; -} - -function RUN(size) { - this.size = size; -} - -ADD.prototype.name = 'ADD'; -COPY.prototype.name = 'COPY'; -RUN.prototype.name = 'RUN'; - -ADD.prototype.execute = function (delta) { - for (var i = 0; i < this.size; i++) { - delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition + i]); +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +__webpack_require__(73); +__webpack_require__(93); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +var _integer = _interopRequireDefault(__webpack_require__(170)); +var TypedArray = _interopRequireWildcard(__webpack_require__(160)); +function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); } +function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; } +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var ADD = /*#__PURE__*/function () { + function ADD(size) { + _classCallCheck(this, ADD); + _defineProperty(this, "name", 'ADD'); + this.size = size; } - - delta.dataPosition += this.size; - delta.UTargetPosition += this.size; -}; - -COPY.prototype.execute = function (delta) { - var address, m, next, method; - - if (this.mode === 0) { - address = delta.getNextAddressInteger(); - } else if (this.mode === 1) { - next = delta.getNextAddressInteger(); - address = delta.UTargetPosition - next; - } else if ((m = this.mode - 2) >= 0 && m < delta.nearCache.size) { - next = delta.getNextAddressInteger(); - address = delta.nearCache.get(m, next); - method = 'near'; - } // same cache - else { - m = this.mode - (2 + delta.nearCache.size); - next = delta.getNextAddressByte(); - address = delta.sameCache.get(m, next); - method = 'same'; + _createClass(ADD, [{ + key: "execute", + value: function execute(delta) { + for (var i = 0; i < this.size; i++) { + delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition + i]); + } + delta.dataPosition += this.size; + delta.UTargetPosition += this.size; } - - delta.nearCache.update(address); - delta.sameCache.update(address); - - for (var i = 0; i < this.size; i++) { - delta.U.set(delta.UTargetPosition + i, delta.U.get(address + i)); + }]); + return ADD; +}(); +var COPY = /*#__PURE__*/function () { + function COPY(size, mode) { + _classCallCheck(this, COPY); + _defineProperty(this, "name", 'COPY'); + this.size = size; + this.mode = mode; } - - delta.UTargetPosition += this.size; -}; - -RUN.prototype.execute = function (delta) { - for (var i = 0; i < this.size; i++) { - // repeat single byte - delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition]); - } // increment to next byte - - - delta.dataPosition++; - delta.UTargetPosition += this.size; -}; - + _createClass(COPY, [{ + key: "execute", + value: function execute(delta) { + var address, m, next, method; + if (this.mode === 0) { + address = delta.getNextAddressInteger(); + } else if (this.mode === 1) { + next = delta.getNextAddressInteger(); + address = delta.UTargetPosition - next; + } else if ((m = this.mode - 2) >= 0 && m < delta.nearCache.size) { + next = delta.getNextAddressInteger(); + address = delta.nearCache.get(m, next); + method = 'near'; + } + // same cache + else { + m = this.mode - (2 + delta.nearCache.size); + next = delta.getNextAddressByte(); + address = delta.sameCache.get(m, next); + method = 'same'; + } + delta.nearCache.update(address); + delta.sameCache.update(address); + for (var i = 0; i < this.size; i++) { + delta.U.set(delta.UTargetPosition + i, delta.U.get(address + i)); + } + delta.UTargetPosition += this.size; + } + }]); + return COPY; +}(); +; +var RUN = /*#__PURE__*/function () { + function RUN(size) { + _classCallCheck(this, RUN); + _defineProperty(this, "name", 'RUN'); + this.size = size; + } + _createClass(RUN, [{ + key: "execute", + value: function execute(delta) { + for (var i = 0; i < this.size; i++) { + // repeat single byte + delta.U.set(delta.UTargetPosition + i, delta.data[delta.dataPosition]); + } + // increment to next byte + delta.dataPosition++; + delta.UTargetPosition += this.size; + } + }]); + return RUN; +}(); var instructions = { ADD: ADD, COPY: COPY, RUN: RUN }; -module.exports = instructions; +var _default = exports["default"] = instructions; /***/ }), -/* 159 */ +/* 174 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -__webpack_require__(160); - -function NearCache(size) { - this.size = size; - this.near = new Array(this.size).fill(0); - this.nextSlot = 0; -} - -NearCache.prototype.update = function (address) { - if (this.near.length > 0) { - this.near[this.nextSlot] = address; - this.nextSlot = (this.nextSlot + 1) % this.near.length; +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(175); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var NearCache = exports["default"] = /*#__PURE__*/function () { + function NearCache(size) { + _classCallCheck(this, NearCache); + this.size = size; + this.near = new Array(this.size).fill(0); + this.nextSlot = 0; } -}; - -NearCache.prototype.get = function (m, offset) { - var address = this.near[m] + offset; - return address; -}; - -module.exports = NearCache; + _createClass(NearCache, [{ + key: "update", + value: function update(address) { + if (this.near.length > 0) { + this.near[this.nextSlot] = address; + this.nextSlot = (this.nextSlot + 1) % this.near.length; + } + } + }, { + key: "get", + value: function get(m, offset) { + var address = this.near[m] + offset; + return address; + } + }]); + return NearCache; +}(); /***/ }), -/* 160 */ +/* 175 */ /***/ (function(module, exports, __webpack_require__) { -var $ = __webpack_require__(3); -var fill = __webpack_require__(88); -var addToUnscopables = __webpack_require__(60); +var $ = __webpack_require__(2); +var fill = __webpack_require__(105); +var addToUnscopables = __webpack_require__(72); // `Array.prototype.fill` method // https://tc39.github.io/ecma262/#sec-array.prototype.fill @@ -5428,31 +6069,56 @@ addToUnscopables('fill'); /***/ }), -/* 161 */ +/* 176 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -__webpack_require__(160); - -function SameCache(size) { - this.size = size; - this.same = new Array(this.size * 256).fill(0); -} - -SameCache.prototype.update = function (address) { - if (this.same.length > 0) { - this.same[address % (this.size * 256)] = address; +__webpack_require__(1); +__webpack_require__(47); +__webpack_require__(71); +__webpack_require__(53); +__webpack_require__(69); +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +__webpack_require__(175); +__webpack_require__(148); +__webpack_require__(149); +__webpack_require__(151); +__webpack_require__(153); +__webpack_require__(98); +__webpack_require__(154); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var SameCache = exports["default"] = /*#__PURE__*/function () { + function SameCache(size) { + _classCallCheck(this, SameCache); + this.size = size; + this.same = new Array(this.size * 256).fill(0); } -}; - -SameCache.prototype.get = function (m, offset) { - var address = this.same[m * 256 + offset]; - return address; -}; - -module.exports = SameCache; + _createClass(SameCache, [{ + key: "update", + value: function update(address) { + if (this.same.length > 0) { + this.same[address % (this.size * 256)] = address; + } + } + }, { + key: "get", + value: function get(m, offset) { + var address = this.same[m * 256 + offset]; + return address; + } + }]); + return SameCache; +}(); /***/ }) /******/ ]); \ No newline at end of file diff --git a/dist/vcdiff-decoder.min.js b/dist/vcdiff-decoder.min.js index 891179d..2259377 100644 --- a/dist/vcdiff-decoder.min.js +++ b/dist/vcdiff-decoder.min.js @@ -1 +1 @@ -var vcdiffDecoder=function(t){var r={};function n(e){if(r[e])return r[e].exports;var o=r[e]={i:e,l:!1,exports:{}};return t[e].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=t,n.c=r,n.d=function(t,r,e){n.o(t,r)||Object.defineProperty(t,r,{enumerable:!0,get:e})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,r){if(1&r&&(t=n(t)),8&r)return t;if(4&r&&"object"==typeof t&&t&&t.__esModule)return t;var e=Object.create(null);if(n.r(e),Object.defineProperty(e,"default",{enumerable:!0,value:t}),2&r&&"string"!=typeof t)for(var o in t)n.d(e,o,function(r){return t[r]}.bind(null,o));return e},n.n=function(t){var r=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(r,"a",r),r},n.o=function(t,r){return Object.prototype.hasOwnProperty.call(t,r)},n.p="",n(n.s=111)}([function(t,r,n){"use strict";var e,o=n(74),i=n(5),u=n(1),a=n(8),s=n(4),c=n(37),f=n(9),p=n(18),l=n(6).f,h=n(35),y=n(27),d=n(2),v=n(32),g=u.Int8Array,w=g&&g.prototype,A=u.Uint8ClampedArray,b=A&&A.prototype,x=g&&h(g),m=w&&h(w),S=Object.prototype,T=S.isPrototypeOf,O=d("toStringTag"),E=v("TYPED_ARRAY_TAG"),P=o&&!!y&&"Opera"!==c(u.opera),I=!1,C={Int8Array:1,Uint8Array:1,Uint8ClampedArray:1,Int16Array:2,Uint16Array:2,Int32Array:4,Uint32Array:4,Float32Array:4,Float64Array:8},_=function(t){return a(t)&&s(C,c(t))};for(e in C)u[e]||(P=!1);if((!P||"function"!=typeof x||x===Function.prototype)&&(x=function(){throw TypeError("Incorrect invocation")},P))for(e in C)u[e]&&y(u[e],x);if((!P||!m||m===S)&&(m=x.prototype,P))for(e in C)u[e]&&y(u[e].prototype,m);if(P&&h(b)!==m&&y(b,m),i&&!s(m,O))for(e in I=!0,l(m,O,{get:function(){return a(this)?this[E]:void 0}}),C)u[e]&&f(u[e],E,e);t.exports={NATIVE_ARRAY_BUFFER_VIEWS:P,TYPED_ARRAY_TAG:I&&E,aTypedArray:function(t){if(_(t))return t;throw TypeError("Target is not a typed array")},aTypedArrayConstructor:function(t){if(y){if(T.call(x,t))return t}else for(var r in C)if(s(C,e)){var n=u[r];if(n&&(t===n||T.call(n,t)))return t}throw TypeError("Target is not a typed array constructor")},exportTypedArrayMethod:function(t,r,n){if(i){if(n)for(var e in C){var o=u[e];o&&s(o.prototype,t)&&delete o.prototype[t]}m[t]&&!n||p(m,t,n?r:P&&w[t]||r)}},exportTypedArrayStaticMethod:function(t,r,n){var e,o;if(i){if(y){if(n)for(e in C)(o=u[e])&&s(o,t)&&delete o[t];if(x[t]&&!n)return;try{return p(x,t,n?r:P&&g[t]||r)}catch(t){}}for(e in C)!(o=u[e])||o[t]&&!n||p(o,t,r)}},isView:function(t){var r=c(t);return"DataView"===r||s(C,r)},isTypedArray:_,TypedArray:x,TypedArrayPrototype:m}},function(t,r,n){(function(r){var n=function(t){return t&&t.Math==Math&&t};t.exports=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof r&&r)||Function("return this")()}).call(this,n(113))},function(t,r,n){var e=n(1),o=n(43),i=n(4),u=n(32),a=n(48),s=n(65),c=o("wks"),f=e.Symbol,p=s?f:f&&f.withoutSetter||u;t.exports=function(t){return i(c,t)||(a&&i(f,t)?c[t]=f[t]:c[t]=p("Symbol."+t)),c[t]}},function(t,r){t.exports=function(t){try{return!!t()}catch(t){return!0}}},function(t,r){var n={}.hasOwnProperty;t.exports=function(t,r){return n.call(t,r)}},function(t,r,n){var e=n(3);t.exports=!e((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},function(t,r,n){var e=n(5),o=n(55),i=n(14),u=n(21),a=Object.defineProperty;r.f=e?a:function(t,r,n){if(i(t),r=u(r,!0),i(n),o)try{return a(t,r,n)}catch(t){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(t[r]=n.value),t}},function(t,r,n){var e=n(16),o=Math.min;t.exports=function(t){return t>0?o(e(t),9007199254740991):0}},function(t,r){t.exports=function(t){return"object"==typeof t?null!==t:"function"==typeof t}},function(t,r,n){var e=n(5),o=n(6),i=n(17);t.exports=e?function(t,r,n){return o.f(t,r,i(1,n))}:function(t,r,n){return t[r]=n,t}},function(t,r,n){var e=n(1),o=n(29).f,i=n(9),u=n(18),a=n(42),s=n(59),c=n(116);t.exports=function(t,r){var n,f,p,l,h,y=t.target,d=t.global,v=t.stat;if(n=d?e:v?e[y]||a(y,{}):(e[y]||{}).prototype)for(f in r){if(l=r[f],p=t.noTargetGet?(h=o(n,f))&&h.value:n[f],!c(d?f:y+(v?".":"#")+f,t.forced)&&void 0!==p){if(typeof l==typeof p)continue;s(l,p)}(t.sham||p&&p.sham)&&i(l,"sham",!0),u(n,f,l,t)}}},function(t,r,n){var e=n(64),o=n(39),i=n(15),u=n(7),a=n(117),s=[].push,c=function(t){var r=1==t,n=2==t,c=3==t,f=4==t,p=6==t,l=5==t||p;return function(h,y,d,v){for(var g,w,A=i(h),b=o(A),x=e(y,d,3),m=u(b.length),S=0,T=v||a,O=r?T(h,m):n?T(h,0):void 0;m>S;S++)if((l||S in b)&&(w=x(g=b[S],S,A),t))if(r)O[S]=w;else if(w)switch(t){case 3:return!0;case 5:return g;case 6:return S;case 2:s.call(O,g)}else if(f)return!1;return p?-1:c||f?f:O}};t.exports={forEach:c(0),map:c(1),filter:c(2),some:c(3),every:c(4),find:c(5),findIndex:c(6)}},function(t,r,n){"use strict";var e=n(10),o=n(1),i=n(5),u=n(130),a=n(0),s=n(73),c=n(75),f=n(17),p=n(9),l=n(7),h=n(76),y=n(79),d=n(21),v=n(4),g=n(37),w=n(8),A=n(25),b=n(27),x=n(23).f,m=n(133),S=n(11).forEach,T=n(136),O=n(6),E=n(29),P=n(19),I=n(137),C=P.get,_=P.set,j=O.f,M=E.f,D=Math.round,L=o.RangeError,R=s.ArrayBuffer,U=s.DataView,Y=a.NATIVE_ARRAY_BUFFER_VIEWS,N=a.TYPED_ARRAY_TAG,z=a.TypedArray,F=a.TypedArrayPrototype,W=a.aTypedArrayConstructor,V=a.isTypedArray,k=function(t,r){for(var n=0,e=r.length,o=new(W(t))(e);e>n;)o[n]=r[n++];return o},B=function(t,r){j(t,r,{get:function(){return C(this)[r]}})},G=function(t){var r;return t instanceof R||"ArrayBuffer"==(r=g(t))||"SharedArrayBuffer"==r},H=function(t,r){return V(t)&&"symbol"!=typeof r&&r in t&&String(+r)==String(r)},q=function(t,r){return H(t,r=d(r,!0))?f(2,t[r]):M(t,r)},$=function(t,r,n){return!(H(t,r=d(r,!0))&&w(n)&&v(n,"value"))||v(n,"get")||v(n,"set")||n.configurable||v(n,"writable")&&!n.writable||v(n,"enumerable")&&!n.enumerable?j(t,r,n):(t[r]=n.value,t)};i?(Y||(E.f=q,O.f=$,B(F,"buffer"),B(F,"byteOffset"),B(F,"byteLength"),B(F,"length")),e({target:"Object",stat:!0,forced:!Y},{getOwnPropertyDescriptor:q,defineProperty:$}),t.exports=function(t,r,n){var i=t.match(/\d+$/)[0]/8,a=t+(n?"Clamped":"")+"Array",s="get"+t,f="set"+t,d=o[a],v=d,g=v&&v.prototype,O={},E=function(t,r){j(t,r,{get:function(){return function(t,r){var n=C(t);return n.view[s](r*i+n.byteOffset,!0)}(this,r)},set:function(t){return function(t,r,e){var o=C(t);n&&(e=(e=D(e))<0?0:e>255?255:255&e),o.view[f](r*i+o.byteOffset,e,!0)}(this,r,t)},enumerable:!0})};Y?u&&(v=r((function(t,r,n,e){return c(t,v,a),I(w(r)?G(r)?void 0!==e?new d(r,y(n,i),e):void 0!==n?new d(r,y(n,i)):new d(r):V(r)?k(v,r):m.call(v,r):new d(h(r)),t,v)})),b&&b(v,z),S(x(d),(function(t){t in v||p(v,t,d[t])})),v.prototype=g):(v=r((function(t,r,n,e){c(t,v,a);var o,u,s,f=0,p=0;if(w(r)){if(!G(r))return V(r)?k(v,r):m.call(v,r);o=r,p=y(n,i);var d=r.byteLength;if(void 0===e){if(d%i)throw L("Wrong length");if((u=d-p)<0)throw L("Wrong length")}else if((u=l(e)*i)+p>d)throw L("Wrong length");s=u/i}else s=h(r),o=new R(u=s*i);for(_(t,{buffer:o,byteOffset:p,byteLength:u,length:s,view:new U(o)});f0?e:n)(t)}},function(t,r){t.exports=function(t,r){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:r}}},function(t,r,n){var e=n(1),o=n(9),i=n(4),u=n(42),a=n(57),s=n(19),c=s.get,f=s.enforce,p=String(String).split("String");(t.exports=function(t,r,n,a){var s=!!a&&!!a.unsafe,c=!!a&&!!a.enumerable,l=!!a&&!!a.noTargetGet;"function"==typeof n&&("string"!=typeof r||i(n,"name")||o(n,"name",r),f(n).source=p.join("string"==typeof r?r:"")),t!==e?(s?!l&&t[r]&&(c=!0):delete t[r],c?t[r]=n:o(t,r,n)):c?t[r]=n:u(r,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&c(this).source||a(this)}))},function(t,r,n){var e,o,i,u=n(114),a=n(1),s=n(8),c=n(9),f=n(4),p=n(30),l=n(33),h=a.WeakMap;if(u){var y=new h,d=y.get,v=y.has,g=y.set;e=function(t,r){return g.call(y,t,r),r},o=function(t){return d.call(y,t)||{}},i=function(t){return v.call(y,t)}}else{var w=p("state");l[w]=!0,e=function(t,r){return c(t,w,r),r},o=function(t){return f(t,w)?t[w]:{}},i=function(t){return f(t,w)}}t.exports={set:e,get:o,has:i,enforce:function(t){return i(t)?o(t):e(t,{})},getterFor:function(t){return function(r){var n;if(!s(r)||(n=o(r)).type!==t)throw TypeError("Incompatible receiver, "+t+" required");return n}}}},function(t,r,n){var e=n(16),o=Math.max,i=Math.min;t.exports=function(t,r){var n=e(t);return n<0?o(n+r,0):i(n,r)}},function(t,r,n){var e=n(8);t.exports=function(t,r){if(!e(t))return t;var n,o;if(r&&"function"==typeof(n=t.toString)&&!e(o=n.call(t)))return o;if("function"==typeof(n=t.valueOf)&&!e(o=n.call(t)))return o;if(!r&&"function"==typeof(n=t.toString)&&!e(o=n.call(t)))return o;throw TypeError("Can't convert object to primitive value")}},function(t,r,n){var e=n(60),o=n(1),i=function(t){return"function"==typeof t?t:void 0};t.exports=function(t,r){return arguments.length<2?i(e[t])||i(o[t]):e[t]&&e[t][r]||o[t]&&o[t][r]}},function(t,r,n){var e=n(61),o=n(45).concat("length","prototype");r.f=Object.getOwnPropertyNames||function(t){return e(t,o)}},function(t,r,n){var e=n(5),o=n(3),i=n(4),u=Object.defineProperty,a={},s=function(t){throw t};t.exports=function(t,r){if(i(a,t))return a[t];r||(r={});var n=[][t],c=!!i(r,"ACCESSORS")&&r.ACCESSORS,f=i(r,0)?r[0]:s,p=i(r,1)?r[1]:void 0;return a[t]=!!n&&!o((function(){if(c&&!e)return!0;var t={length:-1};c?u(t,1,{enumerable:!0,get:s}):t[1]=1,n.call(t,f,p)}))}},function(t,r,n){var e,o=n(14),i=n(118),u=n(45),a=n(33),s=n(119),c=n(56),f=n(30),p=f("IE_PROTO"),l=function(){},h=function(t){return"