5980 lines
185 KiB
JavaScript
5980 lines
185 KiB
JavaScript
/******/ (function() { // webpackBootstrap
|
|
/******/ var __webpack_modules__ = ({
|
|
|
|
/***/ 448:
|
|
/***/ (function(module, exports) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// addapted from the document.currentScript polyfill by Adam Miller
|
|
// MIT license
|
|
// source: https://github.com/amiller-gh/currentScript-polyfill
|
|
|
|
// added support for Firefox https://bugzilla.mozilla.org/show_bug.cgi?id=1620505
|
|
|
|
(function (root, factory) {
|
|
if (true) {
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
|
|
(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
} else {}
|
|
}(typeof self !== 'undefined' ? self : this, function () {
|
|
function getCurrentScript () {
|
|
var descriptor = Object.getOwnPropertyDescriptor(document, 'currentScript')
|
|
// for chrome
|
|
if (!descriptor && 'currentScript' in document && document.currentScript) {
|
|
return document.currentScript
|
|
}
|
|
|
|
// for other browsers with native support for currentScript
|
|
if (descriptor && descriptor.get !== getCurrentScript && document.currentScript) {
|
|
return document.currentScript
|
|
}
|
|
|
|
// IE 8-10 support script readyState
|
|
// IE 11+ & Firefox support stack trace
|
|
try {
|
|
throw new Error();
|
|
}
|
|
catch (err) {
|
|
// Find the second match for the "at" string to get file src url from stack.
|
|
var ieStackRegExp = /.*at [^(]*\((.*):(.+):(.+)\)$/ig,
|
|
ffStackRegExp = /@([^@]*):(\d+):(\d+)\s*$/ig,
|
|
stackDetails = ieStackRegExp.exec(err.stack) || ffStackRegExp.exec(err.stack),
|
|
scriptLocation = (stackDetails && stackDetails[1]) || false,
|
|
line = (stackDetails && stackDetails[2]) || false,
|
|
currentLocation = document.location.href.replace(document.location.hash, ''),
|
|
pageSource,
|
|
inlineScriptSourceRegExp,
|
|
inlineScriptSource,
|
|
scripts = document.getElementsByTagName('script'); // Live NodeList collection
|
|
|
|
if (scriptLocation === currentLocation) {
|
|
pageSource = document.documentElement.outerHTML;
|
|
inlineScriptSourceRegExp = new RegExp('(?:[^\\n]+?\\n){0,' + (line - 2) + '}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*', 'i');
|
|
inlineScriptSource = pageSource.replace(inlineScriptSourceRegExp, '$1').trim();
|
|
}
|
|
|
|
for (var i = 0; i < scripts.length; i++) {
|
|
// If ready state is interactive, return the script tag
|
|
if (scripts[i].readyState === 'interactive') {
|
|
return scripts[i];
|
|
}
|
|
|
|
// If src matches, return the script tag
|
|
if (scripts[i].src === scriptLocation) {
|
|
return scripts[i];
|
|
}
|
|
|
|
// If inline source matches, return the script tag
|
|
if (
|
|
scriptLocation === currentLocation &&
|
|
scripts[i].innerHTML &&
|
|
scripts[i].innerHTML.trim() === inlineScriptSource
|
|
) {
|
|
return scripts[i];
|
|
}
|
|
}
|
|
|
|
// If no match, return null
|
|
return null;
|
|
}
|
|
};
|
|
|
|
return getCurrentScript
|
|
}));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7152:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5500);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2312);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
|
|
// Imports
|
|
|
|
|
|
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
|
|
// Module
|
|
___CSS_LOADER_EXPORT___.push([module.id, ".vtb-wrapper{display:-webkit-box;display:-ms-flexbox;display:flex}", ""]);
|
|
// Exports
|
|
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3776:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5500);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2312);
|
|
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
|
|
// Imports
|
|
|
|
|
|
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
|
|
// Module
|
|
___CSS_LOADER_EXPORT___.push([module.id, ".vtb-item{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:horizontal;-webkit-box-direction:reverse;-ms-flex-direction:row-reverse;flex-direction:row-reverse}.vtb-item p{padding:20px;margin:0;background-color:#999}.vtb-item-parent{position:relative;margin-left:50px;display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center}.vtb-item-players{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;background-color:#999;margin:0;color:#fff}.vtb-item-players .vtb-player{padding:10px}.vtb-item-players .winner{background-color:#006400}.vtb-item-players .defeated{background-color:#b22222}.vtb-item-players .winner.highlight{background-color:#8fbc8f}.vtb-item-players .defeated.highlight{background-color:#cd5c5c}.vtb-item-parent:after{position:absolute;content:\"\";width:25px;height:2px;left:0;top:50%;background-color:gray;-webkit-transform:translateX(-100%);transform:translateX(-100%)}.vtb-item-children{-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}.vtb-item-child,.vtb-item-children{display:-webkit-box;display:-ms-flexbox;display:flex}.vtb-item-child{-webkit-box-align:start;-ms-flex-align:start;align-items:flex-start;-webkit-box-pack:end;-ms-flex-pack:end;justify-content:flex-end;margin-top:10px;margin-bottom:10px;position:relative}.vtb-item-child:before{right:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:25px;height:2px}.vtb-item-child:after,.vtb-item-child:before{content:\"\";position:absolute;background-color:gray;top:50%}.vtb-item-child:after{right:-25px;height:calc(50% + 22px);width:2px}.vtb-item-child:last-child:after{-webkit-transform:translateY(-100%);transform:translateY(-100%)}.vtb-item-child:only-child:after{display:none}", ""]);
|
|
// Exports
|
|
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2312:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
module.exports = function (cssWithMappingToString) {
|
|
var list = [];
|
|
|
|
// return the list of modules as css string
|
|
list.toString = function toString() {
|
|
return this.map(function (item) {
|
|
var content = "";
|
|
var needLayer = typeof item[5] !== "undefined";
|
|
if (item[4]) {
|
|
content += "@supports (".concat(item[4], ") {");
|
|
}
|
|
if (item[2]) {
|
|
content += "@media ".concat(item[2], " {");
|
|
}
|
|
if (needLayer) {
|
|
content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
|
|
}
|
|
content += cssWithMappingToString(item);
|
|
if (needLayer) {
|
|
content += "}";
|
|
}
|
|
if (item[2]) {
|
|
content += "}";
|
|
}
|
|
if (item[4]) {
|
|
content += "}";
|
|
}
|
|
return content;
|
|
}).join("");
|
|
};
|
|
|
|
// import a list of modules into the list
|
|
list.i = function i(modules, media, dedupe, supports, layer) {
|
|
if (typeof modules === "string") {
|
|
modules = [[null, modules, undefined]];
|
|
}
|
|
var alreadyImportedModules = {};
|
|
if (dedupe) {
|
|
for (var k = 0; k < this.length; k++) {
|
|
var id = this[k][0];
|
|
if (id != null) {
|
|
alreadyImportedModules[id] = true;
|
|
}
|
|
}
|
|
}
|
|
for (var _k = 0; _k < modules.length; _k++) {
|
|
var item = [].concat(modules[_k]);
|
|
if (dedupe && alreadyImportedModules[item[0]]) {
|
|
continue;
|
|
}
|
|
if (typeof layer !== "undefined") {
|
|
if (typeof item[5] === "undefined") {
|
|
item[5] = layer;
|
|
} else {
|
|
item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
|
|
item[5] = layer;
|
|
}
|
|
}
|
|
if (media) {
|
|
if (!item[2]) {
|
|
item[2] = media;
|
|
} else {
|
|
item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
|
|
item[2] = media;
|
|
}
|
|
}
|
|
if (supports) {
|
|
if (!item[4]) {
|
|
item[4] = "".concat(supports);
|
|
} else {
|
|
item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
|
|
item[4] = supports;
|
|
}
|
|
}
|
|
list.push(item);
|
|
}
|
|
};
|
|
return list;
|
|
};
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5500:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
|
|
module.exports = function (i) {
|
|
return i[1];
|
|
};
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5796:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
var _objectSpread = (__webpack_require__(2916)["default"]);
|
|
__webpack_require__(6568);
|
|
__webpack_require__(3248);
|
|
__webpack_require__(1040);
|
|
__webpack_require__(9640);
|
|
__webpack_require__(2984);
|
|
module.exports = {
|
|
transform: function transform(rounds) {
|
|
if (!rounds) {
|
|
return null;
|
|
}
|
|
var totalRounds = rounds.length;
|
|
var currentRound = [];
|
|
var previousRound = [];
|
|
var _loop = function _loop(i) {
|
|
currentRound = rounds[i].games.map(function (game) {
|
|
return _objectSpread(_objectSpread({}, game), {}, {
|
|
title: "round " + i,
|
|
games: [],
|
|
hasParent: !!rounds[i + 1]
|
|
});
|
|
});
|
|
if (previousRound.length === 0) {
|
|
previousRound = currentRound;
|
|
return 1; // continue
|
|
}
|
|
for (var j = 0; j < previousRound.length; j++) {
|
|
var matchForCurrentGame = Math.floor(j / 2);
|
|
currentRound[matchForCurrentGame].games.push(previousRound[j]);
|
|
}
|
|
previousRound = currentRound;
|
|
};
|
|
for (var i = 0; i < totalRounds; i++) {
|
|
if (_loop(i)) continue;
|
|
}
|
|
return currentRound[0] || null;
|
|
},
|
|
transformFlatTree: function transformFlatTree(games) {
|
|
var mapOfGamesPerParent = {};
|
|
var root = null;
|
|
games.forEach(function (game) {
|
|
if (!game.next && !root) {
|
|
root = game;
|
|
return;
|
|
}
|
|
if (!mapOfGamesPerParent[game.next]) {
|
|
mapOfGamesPerParent[game.next] = [];
|
|
}
|
|
mapOfGamesPerParent[game.next].push(game);
|
|
});
|
|
var tree = _objectSpread(_objectSpread({}, root), {}, {
|
|
title: "round",
|
|
games: [],
|
|
hasParent: false
|
|
});
|
|
return constructTree(tree, mapOfGamesPerParent, Object.keys(mapOfGamesPerParent).length);
|
|
}
|
|
};
|
|
function constructTree(tree, mapOfChildren, processedRound) {
|
|
var totalChildren = mapOfChildren[tree.id] || [];
|
|
tree.title = "round " + processedRound;
|
|
for (var i = 0; i < totalChildren.length; i++) {
|
|
var childGame = totalChildren[i];
|
|
var treeChild = _objectSpread(_objectSpread({}, childGame), {}, {
|
|
title: "round ".concat([processedRound]),
|
|
hasParent: true,
|
|
games: []
|
|
});
|
|
constructTree(treeChild, mapOfChildren, processedRound - 1);
|
|
tree.games.push(treeChild);
|
|
}
|
|
return tree;
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8152:
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
var __webpack_unused_export__;
|
|
|
|
__webpack_unused_export__ = ({ value: true });
|
|
// runtime helper for setting properties on components
|
|
// in a tree-shakable way
|
|
exports.c = (sfc, props) => {
|
|
const target = sfc.__vccOpts || sfc;
|
|
for (const [key, val] of props) {
|
|
target[key] = val;
|
|
}
|
|
return target;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2142:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
// style-loader: Adds some css to the DOM by adding a <style> tag
|
|
|
|
// load the styles
|
|
var content = __webpack_require__(7152);
|
|
if(content.__esModule) content = content.default;
|
|
if(typeof content === 'string') content = [[module.id, content, '']];
|
|
if(content.locals) module.exports = content.locals;
|
|
// add the styles to the DOM
|
|
var add = (__webpack_require__(8024)/* ["default"] */ .c)
|
|
var update = add("86c520de", content, true, {"sourceMap":false,"shadowMode":false});
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4216:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
// style-loader: Adds some css to the DOM by adding a <style> tag
|
|
|
|
// load the styles
|
|
var content = __webpack_require__(3776);
|
|
if(content.__esModule) content = content.default;
|
|
if(typeof content === 'string') content = [[module.id, content, '']];
|
|
if(content.locals) module.exports = content.locals;
|
|
// add the styles to the DOM
|
|
var add = (__webpack_require__(8024)/* ["default"] */ .c)
|
|
var update = add("4e738482", content, true, {"sourceMap":false,"shadowMode":false});
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8024:
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
c: function() { return /* binding */ addStylesClient; }
|
|
});
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/vue-style-loader/lib/listToStyles.js
|
|
/**
|
|
* Translates the list format produced by css-loader into something
|
|
* easier to manipulate.
|
|
*/
|
|
function listToStyles (parentId, list) {
|
|
var styles = []
|
|
var newStyles = {}
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i]
|
|
var id = item[0]
|
|
var css = item[1]
|
|
var media = item[2]
|
|
var sourceMap = item[3]
|
|
var part = {
|
|
id: parentId + ':' + i,
|
|
css: css,
|
|
media: media,
|
|
sourceMap: sourceMap
|
|
}
|
|
if (!newStyles[id]) {
|
|
styles.push(newStyles[id] = { id: id, parts: [part] })
|
|
} else {
|
|
newStyles[id].parts.push(part)
|
|
}
|
|
}
|
|
return styles
|
|
}
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/vue-style-loader/lib/addStylesClient.js
|
|
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
Modified by Evan You @yyx990803
|
|
*/
|
|
|
|
|
|
|
|
var hasDocument = typeof document !== 'undefined'
|
|
|
|
if (typeof DEBUG !== 'undefined' && DEBUG) {
|
|
if (!hasDocument) {
|
|
throw new Error(
|
|
'vue-style-loader cannot be used in a non-browser environment. ' +
|
|
"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment."
|
|
) }
|
|
}
|
|
|
|
/*
|
|
type StyleObject = {
|
|
id: number;
|
|
parts: Array<StyleObjectPart>
|
|
}
|
|
|
|
type StyleObjectPart = {
|
|
css: string;
|
|
media: string;
|
|
sourceMap: ?string
|
|
}
|
|
*/
|
|
|
|
var stylesInDom = {/*
|
|
[id: number]: {
|
|
id: number,
|
|
refs: number,
|
|
parts: Array<(obj?: StyleObjectPart) => void>
|
|
}
|
|
*/}
|
|
|
|
var head = hasDocument && (document.head || document.getElementsByTagName('head')[0])
|
|
var singletonElement = null
|
|
var singletonCounter = 0
|
|
var isProduction = false
|
|
var noop = function () {}
|
|
var options = null
|
|
var ssrIdKey = 'data-vue-ssr-id'
|
|
|
|
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
|
|
// tags it will allow on a page
|
|
var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase())
|
|
|
|
function addStylesClient (parentId, list, _isProduction, _options) {
|
|
isProduction = _isProduction
|
|
|
|
options = _options || {}
|
|
|
|
var styles = listToStyles(parentId, list)
|
|
addStylesToDom(styles)
|
|
|
|
return function update (newList) {
|
|
var mayRemove = []
|
|
for (var i = 0; i < styles.length; i++) {
|
|
var item = styles[i]
|
|
var domStyle = stylesInDom[item.id]
|
|
domStyle.refs--
|
|
mayRemove.push(domStyle)
|
|
}
|
|
if (newList) {
|
|
styles = listToStyles(parentId, newList)
|
|
addStylesToDom(styles)
|
|
} else {
|
|
styles = []
|
|
}
|
|
for (var i = 0; i < mayRemove.length; i++) {
|
|
var domStyle = mayRemove[i]
|
|
if (domStyle.refs === 0) {
|
|
for (var j = 0; j < domStyle.parts.length; j++) {
|
|
domStyle.parts[j]()
|
|
}
|
|
delete stylesInDom[domStyle.id]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function addStylesToDom (styles /* Array<StyleObject> */) {
|
|
for (var i = 0; i < styles.length; i++) {
|
|
var item = styles[i]
|
|
var domStyle = stylesInDom[item.id]
|
|
if (domStyle) {
|
|
domStyle.refs++
|
|
for (var j = 0; j < domStyle.parts.length; j++) {
|
|
domStyle.parts[j](item.parts[j])
|
|
}
|
|
for (; j < item.parts.length; j++) {
|
|
domStyle.parts.push(addStyle(item.parts[j]))
|
|
}
|
|
if (domStyle.parts.length > item.parts.length) {
|
|
domStyle.parts.length = item.parts.length
|
|
}
|
|
} else {
|
|
var parts = []
|
|
for (var j = 0; j < item.parts.length; j++) {
|
|
parts.push(addStyle(item.parts[j]))
|
|
}
|
|
stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }
|
|
}
|
|
}
|
|
}
|
|
|
|
function createStyleElement () {
|
|
var styleElement = document.createElement('style')
|
|
styleElement.type = 'text/css'
|
|
head.appendChild(styleElement)
|
|
return styleElement
|
|
}
|
|
|
|
function addStyle (obj /* StyleObjectPart */) {
|
|
var update, remove
|
|
var styleElement = document.querySelector('style[' + ssrIdKey + '~="' + obj.id + '"]')
|
|
|
|
if (styleElement) {
|
|
if (isProduction) {
|
|
// has SSR styles and in production mode.
|
|
// simply do nothing.
|
|
return noop
|
|
} else {
|
|
// has SSR styles but in dev mode.
|
|
// for some reason Chrome can't handle source map in server-rendered
|
|
// style tags - source maps in <style> only works if the style tag is
|
|
// created and inserted dynamically. So we remove the server rendered
|
|
// styles and inject new ones.
|
|
styleElement.parentNode.removeChild(styleElement)
|
|
}
|
|
}
|
|
|
|
if (isOldIE) {
|
|
// use singleton mode for IE9.
|
|
var styleIndex = singletonCounter++
|
|
styleElement = singletonElement || (singletonElement = createStyleElement())
|
|
update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)
|
|
remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)
|
|
} else {
|
|
// use multi-style-tag mode in all other cases
|
|
styleElement = createStyleElement()
|
|
update = applyToTag.bind(null, styleElement)
|
|
remove = function () {
|
|
styleElement.parentNode.removeChild(styleElement)
|
|
}
|
|
}
|
|
|
|
update(obj)
|
|
|
|
return function updateStyle (newObj /* StyleObjectPart */) {
|
|
if (newObj) {
|
|
if (newObj.css === obj.css &&
|
|
newObj.media === obj.media &&
|
|
newObj.sourceMap === obj.sourceMap) {
|
|
return
|
|
}
|
|
update(obj = newObj)
|
|
} else {
|
|
remove()
|
|
}
|
|
}
|
|
}
|
|
|
|
var replaceText = (function () {
|
|
var textStore = []
|
|
|
|
return function (index, replacement) {
|
|
textStore[index] = replacement
|
|
return textStore.filter(Boolean).join('\n')
|
|
}
|
|
})()
|
|
|
|
function applyToSingletonTag (styleElement, index, remove, obj) {
|
|
var css = remove ? '' : obj.css
|
|
|
|
if (styleElement.styleSheet) {
|
|
styleElement.styleSheet.cssText = replaceText(index, css)
|
|
} else {
|
|
var cssNode = document.createTextNode(css)
|
|
var childNodes = styleElement.childNodes
|
|
if (childNodes[index]) styleElement.removeChild(childNodes[index])
|
|
if (childNodes.length) {
|
|
styleElement.insertBefore(cssNode, childNodes[index])
|
|
} else {
|
|
styleElement.appendChild(cssNode)
|
|
}
|
|
}
|
|
}
|
|
|
|
function applyToTag (styleElement, obj) {
|
|
var css = obj.css
|
|
var media = obj.media
|
|
var sourceMap = obj.sourceMap
|
|
|
|
if (media) {
|
|
styleElement.setAttribute('media', media)
|
|
}
|
|
if (options.ssrId) {
|
|
styleElement.setAttribute(ssrIdKey, obj.id)
|
|
}
|
|
|
|
if (sourceMap) {
|
|
// https://developer.chrome.com/devtools/docs/javascript-debugging
|
|
// this makes source maps inside style tags work properly in Chrome
|
|
css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */'
|
|
// http://stackoverflow.com/a/26603875
|
|
css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'
|
|
}
|
|
|
|
if (styleElement.styleSheet) {
|
|
styleElement.styleSheet.cssText = css
|
|
} else {
|
|
while (styleElement.firstChild) {
|
|
styleElement.removeChild(styleElement.firstChild)
|
|
}
|
|
styleElement.appendChild(document.createTextNode(css))
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1896:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(9063);
|
|
var tryToString = __webpack_require__(4596);
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `Assert: IsCallable(argument) is true`
|
|
module.exports = function (argument) {
|
|
if (isCallable(argument)) return argument;
|
|
throw new $TypeError(tryToString(argument) + ' is not a function');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9472:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isPossiblePrototype = __webpack_require__(968);
|
|
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
|
|
module.exports = function (argument) {
|
|
if (isPossiblePrototype(argument)) return argument;
|
|
throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2328:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var create = __webpack_require__(8340);
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
|
|
var UNSCOPABLES = wellKnownSymbol('unscopables');
|
|
var ArrayPrototype = Array.prototype;
|
|
|
|
// Array.prototype[@@unscopables]
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
if (ArrayPrototype[UNSCOPABLES] === undefined) {
|
|
defineProperty(ArrayPrototype, UNSCOPABLES, {
|
|
configurable: true,
|
|
value: create(null)
|
|
});
|
|
}
|
|
|
|
// add a key to Array.prototype[@@unscopables]
|
|
module.exports = function (key) {
|
|
ArrayPrototype[UNSCOPABLES][key] = true;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6884:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var charAt = (__webpack_require__(1968).charAt);
|
|
|
|
// `AdvanceStringIndex` abstract operation
|
|
// https://tc39.es/ecma262/#sec-advancestringindex
|
|
module.exports = function (S, index, unicode) {
|
|
return index + (unicode ? charAt(S, index).length : 1);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8424:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isObject = __webpack_require__(808);
|
|
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
|
|
// `Assert: Type(argument) is Object`
|
|
module.exports = function (argument) {
|
|
if (isObject(argument)) return argument;
|
|
throw new $TypeError($String(argument) + ' is not an object');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5935:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $forEach = (__webpack_require__(4904).forEach);
|
|
var arrayMethodIsStrict = __webpack_require__(4528);
|
|
|
|
var STRICT_METHOD = arrayMethodIsStrict('forEach');
|
|
|
|
// `Array.prototype.forEach` method implementation
|
|
// https://tc39.es/ecma262/#sec-array.prototype.foreach
|
|
module.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
|
|
return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
|
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
|
|
} : [].forEach;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2196:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var toAbsoluteIndex = __webpack_require__(4160);
|
|
var lengthOfArrayLike = __webpack_require__(9480);
|
|
|
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
var createMethod = function (IS_INCLUDES) {
|
|
return function ($this, el, fromIndex) {
|
|
var O = toIndexedObject($this);
|
|
var length = lengthOfArrayLike(O);
|
|
var index = toAbsoluteIndex(fromIndex, length);
|
|
var value;
|
|
// Array#includes uses SameValueZero equality algorithm
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
if (IS_INCLUDES && el !== el) while (length > index) {
|
|
value = O[index++];
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
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.es/ecma262/#sec-array.prototype.includes
|
|
includes: createMethod(true),
|
|
// `Array.prototype.indexOf` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.indexof
|
|
indexOf: createMethod(false)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4904:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var bind = __webpack_require__(2880);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var IndexedObject = __webpack_require__(6212);
|
|
var toObject = __webpack_require__(6804);
|
|
var lengthOfArrayLike = __webpack_require__(9480);
|
|
var arraySpeciesCreate = __webpack_require__(8488);
|
|
|
|
var push = uncurryThis([].push);
|
|
|
|
// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` 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 IS_FILTER_REJECT = TYPE === 7;
|
|
var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
|
|
return function ($this, callbackfn, that, specificCreate) {
|
|
var O = toObject($this);
|
|
var self = IndexedObject(O);
|
|
var length = lengthOfArrayLike(self);
|
|
var boundFunction = bind(callbackfn, that);
|
|
var index = 0;
|
|
var create = specificCreate || arraySpeciesCreate;
|
|
var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? 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(target, value); // filter
|
|
} else switch (TYPE) {
|
|
case 4: return false; // every
|
|
case 7: push(target, value); // filterReject
|
|
}
|
|
}
|
|
}
|
|
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
|
|
};
|
|
};
|
|
|
|
module.exports = {
|
|
// `Array.prototype.forEach` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.foreach
|
|
forEach: createMethod(0),
|
|
// `Array.prototype.map` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.map
|
|
map: createMethod(1),
|
|
// `Array.prototype.filter` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.filter
|
|
filter: createMethod(2),
|
|
// `Array.prototype.some` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.some
|
|
some: createMethod(3),
|
|
// `Array.prototype.every` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.every
|
|
every: createMethod(4),
|
|
// `Array.prototype.find` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.find
|
|
find: createMethod(5),
|
|
// `Array.prototype.findIndex` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.findIndex
|
|
findIndex: createMethod(6),
|
|
// `Array.prototype.filterReject` method
|
|
// https://github.com/tc39/proposal-array-filtering
|
|
filterReject: createMethod(7)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7776:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var V8_VERSION = __webpack_require__(3356);
|
|
|
|
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;
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4528:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
|
|
module.exports = function (METHOD_NAME, argument) {
|
|
var method = [][METHOD_NAME];
|
|
return !!method && fails(function () {
|
|
// eslint-disable-next-line no-useless-call -- required for testing
|
|
method.call(null, argument || function () { return 1; }, 1);
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7934:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var isArray = __webpack_require__(1064);
|
|
|
|
var $TypeError = TypeError;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// Safari < 13 does not throw an error in this case
|
|
var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
|
|
// makes no sense without proper strict mode support
|
|
if (this !== undefined) return true;
|
|
try {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty([], 'length', { writable: false }).length = 1;
|
|
} catch (error) {
|
|
return error instanceof TypeError;
|
|
}
|
|
}();
|
|
|
|
module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
|
|
if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
|
|
throw new $TypeError('Cannot set read only .length');
|
|
} return O.length = length;
|
|
} : function (O, length) {
|
|
return O.length = length;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7588:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
module.exports = uncurryThis([].slice);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2244:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isArray = __webpack_require__(1064);
|
|
var isConstructor = __webpack_require__(780);
|
|
var isObject = __webpack_require__(808);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var SPECIES = wellKnownSymbol('species');
|
|
var $Array = Array;
|
|
|
|
// a part of `ArraySpeciesCreate` abstract operation
|
|
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
|
module.exports = function (originalArray) {
|
|
var C;
|
|
if (isArray(originalArray)) {
|
|
C = originalArray.constructor;
|
|
// cross-realm fallback
|
|
if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
|
|
else if (isObject(C)) {
|
|
C = C[SPECIES];
|
|
if (C === null) C = undefined;
|
|
}
|
|
} return C === undefined ? $Array : C;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8488:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var arraySpeciesConstructor = __webpack_require__(2244);
|
|
|
|
// `ArraySpeciesCreate` abstract operation
|
|
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
|
module.exports = function (originalArray, length) {
|
|
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5983:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
var toString = uncurryThis({}.toString);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
module.exports = function (it) {
|
|
return stringSlice(toString(it), 8, -1);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8040:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(1712);
|
|
var isCallable = __webpack_require__(9063);
|
|
var classofRaw = __webpack_require__(5983);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var $Object = Object;
|
|
|
|
// 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' && isCallable(O.callee) ? 'Arguments' : result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4304:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var hasOwn = __webpack_require__(6216);
|
|
var ownKeys = __webpack_require__(9976);
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(4560);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
|
|
module.exports = function (target, source, exceptions) {
|
|
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 (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
|
|
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6740:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
|
|
module.exports = !fails(function () {
|
|
function F() { /* empty */ }
|
|
F.prototype.constructor = null;
|
|
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
|
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2596:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// `CreateIterResultObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-createiterresultobject
|
|
module.exports = function (value, done) {
|
|
return { value: value, done: done };
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3652:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
|
|
module.exports = DESCRIPTORS ? function (object, key, value) {
|
|
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
|
} : function (object, key, value) {
|
|
object[key] = value;
|
|
return object;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9200:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = function (bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value: value
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8931:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toPropertyKey = __webpack_require__(8732);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
|
|
module.exports = function (object, key, value) {
|
|
var propertyKey = toPropertyKey(key);
|
|
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
|
|
else object[propertyKey] = value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6268:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var anObject = __webpack_require__(8424);
|
|
var ordinaryToPrimitive = __webpack_require__(7664);
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `Date.prototype[@@toPrimitive](hint)` method implementation
|
|
// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive
|
|
module.exports = function (hint) {
|
|
anObject(this);
|
|
if (hint === 'string' || hint === 'default') hint = 'string';
|
|
else if (hint !== 'number') throw new $TypeError('Incorrect hint');
|
|
return ordinaryToPrimitive(this, hint);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1720:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var makeBuiltIn = __webpack_require__(316);
|
|
var defineProperty = __webpack_require__(368);
|
|
|
|
module.exports = function (target, name, descriptor) {
|
|
if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
|
|
if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
|
|
return defineProperty.f(target, name, descriptor);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3244:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(9063);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
var makeBuiltIn = __webpack_require__(316);
|
|
var defineGlobalProperty = __webpack_require__(1544);
|
|
|
|
module.exports = function (O, key, value, options) {
|
|
if (!options) options = {};
|
|
var simple = options.enumerable;
|
|
var name = options.name !== undefined ? options.name : key;
|
|
if (isCallable(value)) makeBuiltIn(value, name, options);
|
|
if (options.global) {
|
|
if (simple) O[key] = value;
|
|
else defineGlobalProperty(key, value);
|
|
} else {
|
|
try {
|
|
if (!options.unsafe) delete O[key];
|
|
else if (O[key]) simple = true;
|
|
} catch (error) { /* empty */ }
|
|
if (simple) O[key] = value;
|
|
else definePropertyModule.f(O, key, {
|
|
value: value,
|
|
enumerable: false,
|
|
configurable: !options.nonConfigurable,
|
|
writable: !options.nonWritable
|
|
});
|
|
} return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1544:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
var defineProperty = Object.defineProperty;
|
|
|
|
module.exports = function (key, value) {
|
|
try {
|
|
defineProperty(global, key, { value: value, configurable: true, writable: true });
|
|
} catch (error) {
|
|
global[key] = value;
|
|
} return value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3528:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
|
|
// Detect IE8's incomplete defineProperty implementation
|
|
module.exports = !fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9308:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var isObject = __webpack_require__(808);
|
|
|
|
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) : {};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3272:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
var $TypeError = TypeError;
|
|
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
|
|
|
|
module.exports = function (it) {
|
|
if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
|
|
return it;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5848:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// 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
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8280:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
|
|
var documentCreateElement = __webpack_require__(9308);
|
|
|
|
var classList = documentCreateElement('span').classList;
|
|
var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
|
|
|
|
module.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8232:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3356:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var userAgent = __webpack_require__(8232);
|
|
|
|
var process = global.process;
|
|
var Deno = global.Deno;
|
|
var versions = process && process.versions || Deno && Deno.version;
|
|
var v8 = versions && versions.v8;
|
|
var match, version;
|
|
|
|
if (v8) {
|
|
match = v8.split('.');
|
|
// in old Chrome, versions of V8 isn't V8 = Chrome / 10
|
|
// but their correct versions are not interesting for us
|
|
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
|
|
}
|
|
|
|
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
|
|
// so check `userAgent` even if `.v8` exists, but 0
|
|
if (!version && userAgent) {
|
|
match = userAgent.match(/Edge\/(\d+)/);
|
|
if (!match || match[1] >= 74) {
|
|
match = userAgent.match(/Chrome\/(\d+)/);
|
|
if (match) version = +match[1];
|
|
}
|
|
}
|
|
|
|
module.exports = version;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4656:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// IE8- don't enum bug keys
|
|
module.exports = [
|
|
'constructor',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'toLocaleString',
|
|
'toString',
|
|
'valueOf'
|
|
];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6064:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
var $Error = Error;
|
|
var replace = uncurryThis(''.replace);
|
|
|
|
var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
|
|
// eslint-disable-next-line redos/no-vulnerable -- safe
|
|
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
|
|
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
|
|
|
|
module.exports = function (stack, dropEntries) {
|
|
if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
|
|
while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
|
|
} return stack;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4736:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var clearErrorStack = __webpack_require__(6064);
|
|
var ERROR_STACK_INSTALLABLE = __webpack_require__(1512);
|
|
|
|
// non-standard V8
|
|
var captureStackTrace = Error.captureStackTrace;
|
|
|
|
module.exports = function (error, C, stack, dropEntries) {
|
|
if (ERROR_STACK_INSTALLABLE) {
|
|
if (captureStackTrace) captureStackTrace(error, C);
|
|
else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1512:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
|
|
module.exports = !fails(function () {
|
|
var error = new Error('a');
|
|
if (!('stack' in error)) return true;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
|
|
return error.stack !== 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3748:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var getOwnPropertyDescriptor = (__webpack_require__(4560).f);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var defineGlobalProperty = __webpack_require__(1544);
|
|
var copyConstructorProperties = __webpack_require__(4304);
|
|
var isForced = __webpack_require__(5272);
|
|
|
|
/*
|
|
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.dontCallGetSet - prevent calling a getter on target
|
|
options.name - the .name of the function if it does not match the key
|
|
*/
|
|
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] || defineGlobalProperty(TARGET, {});
|
|
} else {
|
|
target = global[TARGET] && global[TARGET].prototype;
|
|
}
|
|
if (target) for (key in source) {
|
|
sourceProperty = source[key];
|
|
if (options.dontCallGetSet) {
|
|
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);
|
|
}
|
|
defineBuiltIn(target, key, sourceProperty, options);
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6040:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = function (exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8760:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// TODO: Remove from `core-js@4` since it's moved to entry points
|
|
__webpack_require__(2644);
|
|
var call = __webpack_require__(892);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var regexpExec = __webpack_require__(8096);
|
|
var fails = __webpack_require__(6040);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
|
|
var SPECIES = wellKnownSymbol('species');
|
|
var RegExpPrototype = RegExp.prototype;
|
|
|
|
module.exports = function (KEY, exec, FORCED, SHAM) {
|
|
var SYMBOL = wellKnownSymbol(KEY);
|
|
|
|
var DELEGATES_TO_SYMBOL = !fails(function () {
|
|
// String methods call symbol-named RegExp methods
|
|
var O = {};
|
|
O[SYMBOL] = function () { return 7; };
|
|
return ''[KEY](O) !== 7;
|
|
});
|
|
|
|
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
|
|
// Symbol-named RegExp methods call .exec
|
|
var execCalled = false;
|
|
var re = /a/;
|
|
|
|
if (KEY === 'split') {
|
|
// We can't use real regex here since it causes deoptimization
|
|
// and serious performance degradation in V8
|
|
// https://github.com/zloirock/core-js/issues/306
|
|
re = {};
|
|
// RegExp[@@split] doesn't call the regex's exec method, but first creates
|
|
// a new one. We need to return the patched regex when creating the new one.
|
|
re.constructor = {};
|
|
re.constructor[SPECIES] = function () { return re; };
|
|
re.flags = '';
|
|
re[SYMBOL] = /./[SYMBOL];
|
|
}
|
|
|
|
re.exec = function () {
|
|
execCalled = true;
|
|
return null;
|
|
};
|
|
|
|
re[SYMBOL]('');
|
|
return !execCalled;
|
|
});
|
|
|
|
if (
|
|
!DELEGATES_TO_SYMBOL ||
|
|
!DELEGATES_TO_EXEC ||
|
|
FORCED
|
|
) {
|
|
var nativeRegExpMethod = /./[SYMBOL];
|
|
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
|
|
var $exec = regexp.exec;
|
|
if ($exec === regexpExec || $exec === RegExpPrototype.exec) {
|
|
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
|
|
// The native String method already delegates to @@method (this
|
|
// polyfilled function), leasing to infinite recursion.
|
|
// We avoid it by directly calling the native @@method method.
|
|
return { done: true, value: call(nativeRegExpMethod, regexp, str, arg2) };
|
|
}
|
|
return { done: true, value: call(nativeMethod, str, regexp, arg2) };
|
|
}
|
|
return { done: false };
|
|
});
|
|
|
|
defineBuiltIn(String.prototype, KEY, methods[0]);
|
|
defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);
|
|
}
|
|
|
|
if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4744:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_BIND = __webpack_require__(5744);
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
var apply = FunctionPrototype.apply;
|
|
var call = FunctionPrototype.call;
|
|
|
|
// eslint-disable-next-line es/no-reflect -- safe
|
|
module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
|
|
return call.apply(apply, arguments);
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2880:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(8168);
|
|
var aCallable = __webpack_require__(1896);
|
|
var NATIVE_BIND = __webpack_require__(5744);
|
|
|
|
var bind = uncurryThis(uncurryThis.bind);
|
|
|
|
// optional / simple context binding
|
|
module.exports = function (fn, that) {
|
|
aCallable(fn);
|
|
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5744:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
|
|
module.exports = !fails(function () {
|
|
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
|
var test = (function () { /* empty */ }).bind();
|
|
// eslint-disable-next-line no-prototype-builtins -- safe
|
|
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 892:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_BIND = __webpack_require__(5744);
|
|
|
|
var call = Function.prototype.call;
|
|
|
|
module.exports = NATIVE_BIND ? call.bind(call) : function () {
|
|
return call.apply(call, arguments);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3788:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var hasOwn = __webpack_require__(6216);
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
|
|
|
|
var EXISTS = hasOwn(FunctionPrototype, 'name');
|
|
// additional protection from minified / mangled / dropped function names
|
|
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
|
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
|
|
|
|
module.exports = {
|
|
EXISTS: EXISTS,
|
|
PROPER: PROPER,
|
|
CONFIGURABLE: CONFIGURABLE
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6632:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var aCallable = __webpack_require__(1896);
|
|
|
|
module.exports = function (object, key, method) {
|
|
try {
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
|
|
} catch (error) { /* empty */ }
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8168:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classofRaw = __webpack_require__(5983);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
module.exports = function (fn) {
|
|
// Nashorn bug:
|
|
// https://github.com/zloirock/core-js/issues/1128
|
|
// https://github.com/zloirock/core-js/issues/1130
|
|
if (classofRaw(fn) === 'Function') return uncurryThis(fn);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1447:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_BIND = __webpack_require__(5744);
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
var call = FunctionPrototype.call;
|
|
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
|
|
|
|
module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
|
|
return function () {
|
|
return call.apply(fn, arguments);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4960:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var isCallable = __webpack_require__(9063);
|
|
|
|
var aFunction = function (argument) {
|
|
return isCallable(argument) ? argument : undefined;
|
|
};
|
|
|
|
module.exports = function (namespace, method) {
|
|
return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6852:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var isArray = __webpack_require__(1064);
|
|
var isCallable = __webpack_require__(9063);
|
|
var classof = __webpack_require__(5983);
|
|
var toString = __webpack_require__(1992);
|
|
|
|
var push = uncurryThis([].push);
|
|
|
|
module.exports = function (replacer) {
|
|
if (isCallable(replacer)) return replacer;
|
|
if (!isArray(replacer)) return;
|
|
var rawLength = replacer.length;
|
|
var keys = [];
|
|
for (var i = 0; i < rawLength; i++) {
|
|
var element = replacer[i];
|
|
if (typeof element == 'string') push(keys, element);
|
|
else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String') push(keys, toString(element));
|
|
}
|
|
var keysLength = keys.length;
|
|
var root = true;
|
|
return function (key, value) {
|
|
if (root) {
|
|
root = false;
|
|
return value;
|
|
}
|
|
if (isArray(this)) return value;
|
|
for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 364:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var aCallable = __webpack_require__(1896);
|
|
var isNullOrUndefined = __webpack_require__(952);
|
|
|
|
// `GetMethod` abstract operation
|
|
// https://tc39.es/ecma262/#sec-getmethod
|
|
module.exports = function (V, P) {
|
|
var func = V[P];
|
|
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5624:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
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 es/no-global-this -- safe
|
|
check(typeof globalThis == 'object' && globalThis) ||
|
|
check(typeof window == 'object' && window) ||
|
|
// eslint-disable-next-line no-restricted-globals -- safe
|
|
check(typeof self == 'object' && self) ||
|
|
check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) ||
|
|
check(typeof this == 'object' && this) ||
|
|
// eslint-disable-next-line no-new-func -- fallback
|
|
(function () { return this; })() || Function('return this')();
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6216:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var toObject = __webpack_require__(6804);
|
|
|
|
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
|
|
|
|
// `HasOwnProperty` abstract operation
|
|
// https://tc39.es/ecma262/#sec-hasownproperty
|
|
// eslint-disable-next-line es/no-object-hasown -- safe
|
|
module.exports = Object.hasOwn || function hasOwn(it, key) {
|
|
return hasOwnProperty(toObject(it), key);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6480:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6836:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
|
|
module.exports = getBuiltIn('document', 'documentElement');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 784:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var fails = __webpack_require__(6040);
|
|
var createElement = __webpack_require__(9308);
|
|
|
|
// Thanks to IE8 for its funny defineProperty
|
|
module.exports = !DESCRIPTORS && !fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty(createElement('div'), 'a', {
|
|
get: function () { return 7; }
|
|
}).a !== 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6212:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var fails = __webpack_require__(6040);
|
|
var classof = __webpack_require__(5983);
|
|
|
|
var $Object = Object;
|
|
var split = uncurryThis(''.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 -- safe
|
|
return !$Object('z').propertyIsEnumerable(0);
|
|
}) ? function (it) {
|
|
return classof(it) === 'String' ? split(it, '') : $Object(it);
|
|
} : $Object;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2744:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(9063);
|
|
var isObject = __webpack_require__(808);
|
|
var setPrototypeOf = __webpack_require__(5168);
|
|
|
|
// 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
|
|
isCallable(NewTarget = dummy.constructor) &&
|
|
NewTarget !== Wrapper &&
|
|
isObject(NewTargetPrototype = NewTarget.prototype) &&
|
|
NewTargetPrototype !== Wrapper.prototype
|
|
) setPrototypeOf($this, NewTargetPrototype);
|
|
return $this;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8460:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var isCallable = __webpack_require__(9063);
|
|
var store = __webpack_require__(9136);
|
|
|
|
var functionToString = uncurryThis(Function.toString);
|
|
|
|
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
|
|
if (!isCallable(store.inspectSource)) {
|
|
store.inspectSource = function (it) {
|
|
return functionToString(it);
|
|
};
|
|
}
|
|
|
|
module.exports = store.inspectSource;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8712:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isObject = __webpack_require__(808);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
|
|
// `InstallErrorCause` abstract operation
|
|
// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
|
|
module.exports = function (O, options) {
|
|
if (isObject(options) && 'cause' in options) {
|
|
createNonEnumerableProperty(O, 'cause', options.cause);
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5444:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_WEAK_MAP = __webpack_require__(280);
|
|
var global = __webpack_require__(5624);
|
|
var isObject = __webpack_require__(808);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var shared = __webpack_require__(9136);
|
|
var sharedKey = __webpack_require__(8192);
|
|
var hiddenKeys = __webpack_require__(6480);
|
|
|
|
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
|
var TypeError = global.TypeError;
|
|
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 new TypeError('Incompatible receiver, ' + TYPE + ' required');
|
|
} return state;
|
|
};
|
|
};
|
|
|
|
if (NATIVE_WEAK_MAP || shared.state) {
|
|
var store = shared.state || (shared.state = new WeakMap());
|
|
/* eslint-disable no-self-assign -- prototype methods protection */
|
|
store.get = store.get;
|
|
store.has = store.has;
|
|
store.set = store.set;
|
|
/* eslint-enable no-self-assign -- prototype methods protection */
|
|
set = function (it, metadata) {
|
|
if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
store.set(it, metadata);
|
|
return metadata;
|
|
};
|
|
get = function (it) {
|
|
return store.get(it) || {};
|
|
};
|
|
has = function (it) {
|
|
return store.has(it);
|
|
};
|
|
} else {
|
|
var STATE = sharedKey('state');
|
|
hiddenKeys[STATE] = true;
|
|
set = function (it, metadata) {
|
|
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
createNonEnumerableProperty(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function (it) {
|
|
return hasOwn(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function (it) {
|
|
return hasOwn(it, STATE);
|
|
};
|
|
}
|
|
|
|
module.exports = {
|
|
set: set,
|
|
get: get,
|
|
has: has,
|
|
enforce: enforce,
|
|
getterFor: getterFor
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1064:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classof = __webpack_require__(5983);
|
|
|
|
// `IsArray` abstract operation
|
|
// https://tc39.es/ecma262/#sec-isarray
|
|
// eslint-disable-next-line es/no-array-isarray -- safe
|
|
module.exports = Array.isArray || function isArray(argument) {
|
|
return classof(argument) === 'Array';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9063:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
|
var documentAll = typeof document == 'object' && document.all;
|
|
|
|
// `IsCallable` abstract operation
|
|
// https://tc39.es/ecma262/#sec-iscallable
|
|
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
|
module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
|
|
return typeof argument == 'function' || argument === documentAll;
|
|
} : function (argument) {
|
|
return typeof argument == 'function';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 780:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var fails = __webpack_require__(6040);
|
|
var isCallable = __webpack_require__(9063);
|
|
var classof = __webpack_require__(8040);
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var inspectSource = __webpack_require__(8460);
|
|
|
|
var noop = function () { /* empty */ };
|
|
var construct = getBuiltIn('Reflect', 'construct');
|
|
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
var exec = uncurryThis(constructorRegExp.exec);
|
|
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
|
|
|
|
var isConstructorModern = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
try {
|
|
construct(noop, [], argument);
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var isConstructorLegacy = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
switch (classof(argument)) {
|
|
case 'AsyncFunction':
|
|
case 'GeneratorFunction':
|
|
case 'AsyncGeneratorFunction': return false;
|
|
}
|
|
try {
|
|
// we can't check .prototype since constructors produced by .bind haven't it
|
|
// `Function#toString` throws on some built-it function in some legacy engines
|
|
// (for example, `DOMQuad` and similar in FF41-)
|
|
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
isConstructorLegacy.sham = true;
|
|
|
|
// `IsConstructor` abstract operation
|
|
// https://tc39.es/ecma262/#sec-isconstructor
|
|
module.exports = !construct || fails(function () {
|
|
var called;
|
|
return isConstructorModern(isConstructorModern.call)
|
|
|| !isConstructorModern(Object)
|
|
|| !isConstructorModern(function () { called = true; })
|
|
|| called;
|
|
}) ? isConstructorLegacy : isConstructorModern;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5272:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var isCallable = __webpack_require__(9063);
|
|
|
|
var replacement = /#|\.prototype\./;
|
|
|
|
var isForced = function (feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value === POLYFILL ? true
|
|
: value === NATIVE ? false
|
|
: isCallable(detection) ? 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;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 952:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// we can't use just `it == null` since of `document.all` special case
|
|
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
|
|
module.exports = function (it) {
|
|
return it === null || it === undefined;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 808:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isCallable = __webpack_require__(9063);
|
|
|
|
module.exports = function (it) {
|
|
return typeof it == 'object' ? it !== null : isCallable(it);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 968:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isObject = __webpack_require__(808);
|
|
|
|
module.exports = function (argument) {
|
|
return isObject(argument) || argument === null;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2804:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = false;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6232:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var isCallable = __webpack_require__(9063);
|
|
var isPrototypeOf = __webpack_require__(6056);
|
|
var USE_SYMBOL_AS_UID = __webpack_require__(9448);
|
|
|
|
var $Object = Object;
|
|
|
|
module.exports = USE_SYMBOL_AS_UID ? function (it) {
|
|
return typeof it == 'symbol';
|
|
} : function (it) {
|
|
var $Symbol = getBuiltIn('Symbol');
|
|
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7936:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var IteratorPrototype = (__webpack_require__(5412).IteratorPrototype);
|
|
var create = __webpack_require__(8340);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
var setToStringTag = __webpack_require__(4200);
|
|
var Iterators = __webpack_require__(4920);
|
|
|
|
var returnThis = function () { return this; };
|
|
|
|
module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
|
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
|
|
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
|
|
Iterators[TO_STRING_TAG] = returnThis;
|
|
return IteratorConstructor;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8752:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var call = __webpack_require__(892);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
var FunctionName = __webpack_require__(3788);
|
|
var isCallable = __webpack_require__(9063);
|
|
var createIteratorConstructor = __webpack_require__(7936);
|
|
var getPrototypeOf = __webpack_require__(1304);
|
|
var setPrototypeOf = __webpack_require__(5168);
|
|
var setToStringTag = __webpack_require__(4200);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var Iterators = __webpack_require__(4920);
|
|
var IteratorsCore = __webpack_require__(5412);
|
|
|
|
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
|
|
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
|
|
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 && 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 (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
|
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
if (setPrototypeOf) {
|
|
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
|
|
} else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
|
|
defineBuiltIn(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.prototype.{ values, @@iterator }.name in V8 / FF
|
|
if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
|
|
createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
|
|
} else {
|
|
INCORRECT_VALUES_NAME = true;
|
|
defaultIterator = function values() { return call(nativeIterator, this); };
|
|
}
|
|
}
|
|
|
|
// 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)) {
|
|
defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
|
|
}
|
|
} else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
|
|
}
|
|
|
|
// define iterator
|
|
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
|
|
defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });
|
|
}
|
|
Iterators[NAME] = defaultIterator;
|
|
|
|
return methods;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5412:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var isCallable = __webpack_require__(9063);
|
|
var isObject = __webpack_require__(808);
|
|
var create = __webpack_require__(8340);
|
|
var getPrototypeOf = __webpack_require__(1304);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var BUGGY_SAFARI_ITERATORS = false;
|
|
|
|
// `%IteratorPrototype%` object
|
|
// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
|
|
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
|
|
|
|
/* eslint-disable es/no-array-prototype-keys -- safe */
|
|
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;
|
|
}
|
|
}
|
|
|
|
var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
|
|
var test = {};
|
|
// FF44- legacy iterators case
|
|
return IteratorPrototype[ITERATOR].call(test) !== test;
|
|
});
|
|
|
|
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
|
|
else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
|
|
|
|
// `%IteratorPrototype%[@@iterator]()` method
|
|
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
|
|
if (!isCallable(IteratorPrototype[ITERATOR])) {
|
|
defineBuiltIn(IteratorPrototype, ITERATOR, function () {
|
|
return this;
|
|
});
|
|
}
|
|
|
|
module.exports = {
|
|
IteratorPrototype: IteratorPrototype,
|
|
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4920:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9480:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toLength = __webpack_require__(960);
|
|
|
|
// `LengthOfArrayLike` abstract operation
|
|
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
|
module.exports = function (obj) {
|
|
return toLength(obj.length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 316:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var fails = __webpack_require__(6040);
|
|
var isCallable = __webpack_require__(9063);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(3788).CONFIGURABLE);
|
|
var inspectSource = __webpack_require__(8460);
|
|
var InternalStateModule = __webpack_require__(5444);
|
|
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var getInternalState = InternalStateModule.get;
|
|
var $String = String;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
var defineProperty = Object.defineProperty;
|
|
var stringSlice = uncurryThis(''.slice);
|
|
var replace = uncurryThis(''.replace);
|
|
var join = uncurryThis([].join);
|
|
|
|
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
|
|
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
|
});
|
|
|
|
var TEMPLATE = String(String).split('String');
|
|
|
|
var makeBuiltIn = module.exports = function (value, name, options) {
|
|
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
|
|
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
|
|
}
|
|
if (options && options.getter) name = 'get ' + name;
|
|
if (options && options.setter) name = 'set ' + name;
|
|
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
|
|
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
|
|
else value.name = name;
|
|
}
|
|
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
|
|
defineProperty(value, 'length', { value: options.arity });
|
|
}
|
|
try {
|
|
if (options && hasOwn(options, 'constructor') && options.constructor) {
|
|
if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
|
|
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
|
|
} else if (value.prototype) value.prototype = undefined;
|
|
} catch (error) { /* empty */ }
|
|
var state = enforceInternalState(value);
|
|
if (!hasOwn(state, 'source')) {
|
|
state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
|
|
} return value;
|
|
};
|
|
|
|
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
|
// eslint-disable-next-line no-extend-native -- required
|
|
Function.prototype.toString = makeBuiltIn(function toString() {
|
|
return isCallable(this) && getInternalState(this).source || inspectSource(this);
|
|
}, 'toString');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1736:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
var ceil = Math.ceil;
|
|
var floor = Math.floor;
|
|
|
|
// `Math.trunc` method
|
|
// https://tc39.es/ecma262/#sec-math.trunc
|
|
// eslint-disable-next-line es/no-math-trunc -- safe
|
|
module.exports = Math.trunc || function trunc(x) {
|
|
var n = +x;
|
|
return (n > 0 ? floor : ceil)(n);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8659:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toString = __webpack_require__(1992);
|
|
|
|
module.exports = function (argument, $default) {
|
|
return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7048:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var call = __webpack_require__(892);
|
|
var fails = __webpack_require__(6040);
|
|
var objectKeys = __webpack_require__(4152);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(8167);
|
|
var propertyIsEnumerableModule = __webpack_require__(2460);
|
|
var toObject = __webpack_require__(6804);
|
|
var IndexedObject = __webpack_require__(6212);
|
|
|
|
// eslint-disable-next-line es/no-object-assign -- safe
|
|
var $assign = Object.assign;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
var defineProperty = Object.defineProperty;
|
|
var concat = uncurryThis([].concat);
|
|
|
|
// `Object.assign` method
|
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
module.exports = !$assign || fails(function () {
|
|
// should have correct order of operations (Edge bug)
|
|
if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
|
|
enumerable: true,
|
|
get: function () {
|
|
defineProperty(this, 'b', {
|
|
value: 3,
|
|
enumerable: false
|
|
});
|
|
}
|
|
}), { b: 2 })).b !== 1) return true;
|
|
// should work with symbols and should have deterministic property order (V8 bug)
|
|
var A = {};
|
|
var B = {};
|
|
// eslint-disable-next-line es/no-symbol -- safe
|
|
var symbol = Symbol('assign detection');
|
|
var alphabet = 'abcdefghijklmnopqrst';
|
|
A[symbol] = 7;
|
|
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
|
|
return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
|
|
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
|
|
var T = toObject(target);
|
|
var argumentsLength = arguments.length;
|
|
var index = 1;
|
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
var propertyIsEnumerable = propertyIsEnumerableModule.f;
|
|
while (argumentsLength > index) {
|
|
var S = IndexedObject(arguments[index++]);
|
|
var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
|
|
var length = keys.length;
|
|
var j = 0;
|
|
var key;
|
|
while (length > j) {
|
|
key = keys[j++];
|
|
if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
|
|
}
|
|
} return T;
|
|
} : $assign;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8340:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* global ActiveXObject -- old IE, WSH */
|
|
var anObject = __webpack_require__(8424);
|
|
var definePropertiesModule = __webpack_require__(5045);
|
|
var enumBugKeys = __webpack_require__(4656);
|
|
var hiddenKeys = __webpack_require__(6480);
|
|
var html = __webpack_require__(6836);
|
|
var documentCreateElement = __webpack_require__(9308);
|
|
var sharedKey = __webpack_require__(8192);
|
|
|
|
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 {
|
|
activeXDocument = new ActiveXObject('htmlfile');
|
|
} catch (error) { /* ignore */ }
|
|
NullProtoObject = typeof document != 'undefined'
|
|
? document.domain && activeXDocument
|
|
? NullProtoObjectViaActiveX(activeXDocument) // old IE
|
|
: NullProtoObjectViaIFrame()
|
|
: NullProtoObjectViaActiveX(activeXDocument); // WSH
|
|
var length = enumBugKeys.length;
|
|
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
|
return NullProtoObject();
|
|
};
|
|
|
|
hiddenKeys[IE_PROTO] = true;
|
|
|
|
// `Object.create` method
|
|
// https://tc39.es/ecma262/#sec-object.create
|
|
// eslint-disable-next-line es/no-object-create -- safe
|
|
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 : definePropertiesModule.f(result, Properties);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5045:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(4859);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
var anObject = __webpack_require__(8424);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var objectKeys = __webpack_require__(4152);
|
|
|
|
// `Object.defineProperties` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperties
|
|
// eslint-disable-next-line es/no-object-defineproperties -- safe
|
|
exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var props = toIndexedObject(Properties);
|
|
var keys = objectKeys(Properties);
|
|
var length = keys.length;
|
|
var index = 0;
|
|
var key;
|
|
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 368:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var IE8_DOM_DEFINE = __webpack_require__(784);
|
|
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(4859);
|
|
var anObject = __webpack_require__(8424);
|
|
var toPropertyKey = __webpack_require__(8732);
|
|
|
|
var $TypeError = TypeError;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
var $defineProperty = Object.defineProperty;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var ENUMERABLE = 'enumerable';
|
|
var CONFIGURABLE = 'configurable';
|
|
var WRITABLE = 'writable';
|
|
|
|
// `Object.defineProperty` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
|
var current = $getOwnPropertyDescriptor(O, P);
|
|
if (current && current[WRITABLE]) {
|
|
O[P] = Attributes.value;
|
|
Attributes = {
|
|
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
|
|
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
|
writable: false
|
|
};
|
|
}
|
|
} return $defineProperty(O, P, Attributes);
|
|
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $defineProperty(O, P, Attributes);
|
|
} catch (error) { /* empty */ }
|
|
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
|
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4560:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var call = __webpack_require__(892);
|
|
var propertyIsEnumerableModule = __webpack_require__(2460);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var toPropertyKey = __webpack_require__(8732);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var IE8_DOM_DEFINE = __webpack_require__(784);
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// `Object.getOwnPropertyDescriptor` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
|
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
O = toIndexedObject(O);
|
|
P = toPropertyKey(P);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $getOwnPropertyDescriptor(O, P);
|
|
} catch (error) { /* empty */ }
|
|
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4856:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable es/no-object-getownpropertynames -- safe */
|
|
var classof = __webpack_require__(5983);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var $getOwnPropertyNames = (__webpack_require__(692).f);
|
|
var arraySlice = __webpack_require__(7588);
|
|
|
|
var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
|
|
? Object.getOwnPropertyNames(window) : [];
|
|
|
|
var getWindowNames = function (it) {
|
|
try {
|
|
return $getOwnPropertyNames(it);
|
|
} catch (error) {
|
|
return arraySlice(windowNames);
|
|
}
|
|
};
|
|
|
|
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
|
|
module.exports.f = function getOwnPropertyNames(it) {
|
|
return windowNames && classof(it) === 'Window'
|
|
? getWindowNames(it)
|
|
: $getOwnPropertyNames(toIndexedObject(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 692:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var internalObjectKeys = __webpack_require__(9232);
|
|
var enumBugKeys = __webpack_require__(4656);
|
|
|
|
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
|
|
|
|
// `Object.getOwnPropertyNames` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertynames
|
|
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
|
|
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
|
return internalObjectKeys(O, hiddenKeys);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8167:
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
|
exports.f = Object.getOwnPropertySymbols;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1304:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var hasOwn = __webpack_require__(6216);
|
|
var isCallable = __webpack_require__(9063);
|
|
var toObject = __webpack_require__(6804);
|
|
var sharedKey = __webpack_require__(8192);
|
|
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(6740);
|
|
|
|
var IE_PROTO = sharedKey('IE_PROTO');
|
|
var $Object = Object;
|
|
var ObjectPrototype = $Object.prototype;
|
|
|
|
// `Object.getPrototypeOf` method
|
|
// https://tc39.es/ecma262/#sec-object.getprototypeof
|
|
// eslint-disable-next-line es/no-object-getprototypeof -- safe
|
|
module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
|
var object = toObject(O);
|
|
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
|
|
var constructor = object.constructor;
|
|
if (isCallable(constructor) && object instanceof constructor) {
|
|
return constructor.prototype;
|
|
} return object instanceof $Object ? ObjectPrototype : null;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6056:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
module.exports = uncurryThis({}.isPrototypeOf);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9232:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var indexOf = (__webpack_require__(2196).indexOf);
|
|
var hiddenKeys = __webpack_require__(6480);
|
|
|
|
var push = uncurryThis([].push);
|
|
|
|
module.exports = function (object, names) {
|
|
var O = toIndexedObject(object);
|
|
var i = 0;
|
|
var result = [];
|
|
var key;
|
|
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
|
|
// Don't enum bug & hidden keys
|
|
while (names.length > i) if (hasOwn(O, key = names[i++])) {
|
|
~indexOf(result, key) || push(result, key);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4152:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var internalObjectKeys = __webpack_require__(9232);
|
|
var enumBugKeys = __webpack_require__(4656);
|
|
|
|
// `Object.keys` method
|
|
// https://tc39.es/ecma262/#sec-object.keys
|
|
// eslint-disable-next-line es/no-object-keys -- safe
|
|
module.exports = Object.keys || function keys(O) {
|
|
return internalObjectKeys(O, enumBugKeys);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2460:
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
|
|
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// Nashorn ~ JDK8 bug
|
|
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
|
|
|
|
// `Object.prototype.propertyIsEnumerable` method implementation
|
|
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
|
|
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
|
var descriptor = getOwnPropertyDescriptor(this, V);
|
|
return !!descriptor && descriptor.enumerable;
|
|
} : $propertyIsEnumerable;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5168:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable no-proto -- safe */
|
|
var uncurryThisAccessor = __webpack_require__(6632);
|
|
var anObject = __webpack_require__(8424);
|
|
var aPossiblePrototype = __webpack_require__(9472);
|
|
|
|
// `Object.setPrototypeOf` method
|
|
// https://tc39.es/ecma262/#sec-object.setprototypeof
|
|
// Works with __proto__ only. Old v8 can't work with null proto objects.
|
|
// eslint-disable-next-line es/no-object-setprototypeof -- safe
|
|
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
|
|
var CORRECT_SETTER = false;
|
|
var test = {};
|
|
var setter;
|
|
try {
|
|
setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
|
|
setter(test, []);
|
|
CORRECT_SETTER = test instanceof Array;
|
|
} catch (error) { /* empty */ }
|
|
return function setPrototypeOf(O, proto) {
|
|
anObject(O);
|
|
aPossiblePrototype(proto);
|
|
if (CORRECT_SETTER) setter(O, proto);
|
|
else O.__proto__ = proto;
|
|
return O;
|
|
};
|
|
}() : undefined);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3532:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(1712);
|
|
var classof = __webpack_require__(8040);
|
|
|
|
// `Object.prototype.toString` method implementation
|
|
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
|
module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
|
|
return '[object ' + classof(this) + ']';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7664:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(892);
|
|
var isCallable = __webpack_require__(9063);
|
|
var isObject = __webpack_require__(808);
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `OrdinaryToPrimitive` abstract operation
|
|
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
|
|
module.exports = function (input, pref) {
|
|
var fn, val;
|
|
if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
|
|
if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
throw new $TypeError("Can't convert object to primitive value");
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9976:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var getOwnPropertyNamesModule = __webpack_require__(692);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(8167);
|
|
var anObject = __webpack_require__(8424);
|
|
|
|
var concat = uncurryThis([].concat);
|
|
|
|
// 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 ? concat(keys, getOwnPropertySymbols(it)) : keys;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4880:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
|
|
module.exports = global;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9904:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
|
|
module.exports = function (Target, Source, key) {
|
|
key in Target || defineProperty(Target, key, {
|
|
configurable: true,
|
|
get: function () { return Source[key]; },
|
|
set: function (it) { Source[key] = it; }
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1456:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(892);
|
|
var anObject = __webpack_require__(8424);
|
|
var isCallable = __webpack_require__(9063);
|
|
var classof = __webpack_require__(5983);
|
|
var regexpExec = __webpack_require__(8096);
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `RegExpExec` abstract operation
|
|
// https://tc39.es/ecma262/#sec-regexpexec
|
|
module.exports = function (R, S) {
|
|
var exec = R.exec;
|
|
if (isCallable(exec)) {
|
|
var result = call(exec, R, S);
|
|
if (result !== null) anObject(result);
|
|
return result;
|
|
}
|
|
if (classof(R) === 'RegExp') return call(regexpExec, R, S);
|
|
throw new $TypeError('RegExp#exec called on incompatible receiver');
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8096:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
|
|
/* eslint-disable regexp/no-useless-quantifier -- testing */
|
|
var call = __webpack_require__(892);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var toString = __webpack_require__(1992);
|
|
var regexpFlags = __webpack_require__(8020);
|
|
var stickyHelpers = __webpack_require__(8548);
|
|
var shared = __webpack_require__(8196);
|
|
var create = __webpack_require__(8340);
|
|
var getInternalState = (__webpack_require__(5444).get);
|
|
var UNSUPPORTED_DOT_ALL = __webpack_require__(9160);
|
|
var UNSUPPORTED_NCG = __webpack_require__(7416);
|
|
|
|
var nativeReplace = shared('native-string-replace', String.prototype.replace);
|
|
var nativeExec = RegExp.prototype.exec;
|
|
var patchedExec = nativeExec;
|
|
var charAt = uncurryThis(''.charAt);
|
|
var indexOf = uncurryThis(''.indexOf);
|
|
var replace = uncurryThis(''.replace);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
var UPDATES_LAST_INDEX_WRONG = (function () {
|
|
var re1 = /a/;
|
|
var re2 = /b*/g;
|
|
call(nativeExec, re1, 'a');
|
|
call(nativeExec, re2, 'a');
|
|
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
|
|
})();
|
|
|
|
var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
|
|
|
|
// nonparticipating capturing group, copied from es5-shim's String#split patch.
|
|
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
|
|
|
|
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
|
|
|
|
if (PATCH) {
|
|
patchedExec = function exec(string) {
|
|
var re = this;
|
|
var state = getInternalState(re);
|
|
var str = toString(string);
|
|
var raw = state.raw;
|
|
var result, reCopy, lastIndex, match, i, object, group;
|
|
|
|
if (raw) {
|
|
raw.lastIndex = re.lastIndex;
|
|
result = call(patchedExec, raw, str);
|
|
re.lastIndex = raw.lastIndex;
|
|
return result;
|
|
}
|
|
|
|
var groups = state.groups;
|
|
var sticky = UNSUPPORTED_Y && re.sticky;
|
|
var flags = call(regexpFlags, re);
|
|
var source = re.source;
|
|
var charsAdded = 0;
|
|
var strCopy = str;
|
|
|
|
if (sticky) {
|
|
flags = replace(flags, 'y', '');
|
|
if (indexOf(flags, 'g') === -1) {
|
|
flags += 'g';
|
|
}
|
|
|
|
strCopy = stringSlice(str, re.lastIndex);
|
|
// Support anchored sticky behavior.
|
|
if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(str, re.lastIndex - 1) !== '\n')) {
|
|
source = '(?: ' + source + ')';
|
|
strCopy = ' ' + strCopy;
|
|
charsAdded++;
|
|
}
|
|
// ^(? + rx + ) is needed, in combination with some str slicing, to
|
|
// simulate the 'y' flag.
|
|
reCopy = new RegExp('^(?:' + source + ')', flags);
|
|
}
|
|
|
|
if (NPCG_INCLUDED) {
|
|
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
|
|
}
|
|
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
|
|
|
|
match = call(nativeExec, sticky ? reCopy : re, strCopy);
|
|
|
|
if (sticky) {
|
|
if (match) {
|
|
match.input = stringSlice(match.input, charsAdded);
|
|
match[0] = stringSlice(match[0], charsAdded);
|
|
match.index = re.lastIndex;
|
|
re.lastIndex += match[0].length;
|
|
} else re.lastIndex = 0;
|
|
} else if (UPDATES_LAST_INDEX_WRONG && match) {
|
|
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
|
|
}
|
|
if (NPCG_INCLUDED && match && match.length > 1) {
|
|
// Fix browsers whose `exec` methods don't consistently return `undefined`
|
|
// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
|
|
call(nativeReplace, match[0], reCopy, function () {
|
|
for (i = 1; i < arguments.length - 2; i++) {
|
|
if (arguments[i] === undefined) match[i] = undefined;
|
|
}
|
|
});
|
|
}
|
|
|
|
if (match && groups) {
|
|
match.groups = object = create(null);
|
|
for (i = 0; i < groups.length; i++) {
|
|
group = groups[i];
|
|
object[group[0]] = match[group[1]];
|
|
}
|
|
}
|
|
|
|
return match;
|
|
};
|
|
}
|
|
|
|
module.exports = patchedExec;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8020:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var anObject = __webpack_require__(8424);
|
|
|
|
// `RegExp.prototype.flags` getter implementation
|
|
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
|
module.exports = function () {
|
|
var that = anObject(this);
|
|
var result = '';
|
|
if (that.hasIndices) result += 'd';
|
|
if (that.global) result += 'g';
|
|
if (that.ignoreCase) result += 'i';
|
|
if (that.multiline) result += 'm';
|
|
if (that.dotAll) result += 's';
|
|
if (that.unicode) result += 'u';
|
|
if (that.unicodeSets) result += 'v';
|
|
if (that.sticky) result += 'y';
|
|
return result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8548:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var global = __webpack_require__(5624);
|
|
|
|
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
|
|
var $RegExp = global.RegExp;
|
|
|
|
var UNSUPPORTED_Y = fails(function () {
|
|
var re = $RegExp('a', 'y');
|
|
re.lastIndex = 2;
|
|
return re.exec('abcd') !== null;
|
|
});
|
|
|
|
// UC Browser bug
|
|
// https://github.com/zloirock/core-js/issues/1008
|
|
var MISSED_STICKY = UNSUPPORTED_Y || fails(function () {
|
|
return !$RegExp('a', 'y').sticky;
|
|
});
|
|
|
|
var BROKEN_CARET = UNSUPPORTED_Y || fails(function () {
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
|
|
var re = $RegExp('^r', 'gy');
|
|
re.lastIndex = 2;
|
|
return re.exec('str') !== null;
|
|
});
|
|
|
|
module.exports = {
|
|
BROKEN_CARET: BROKEN_CARET,
|
|
MISSED_STICKY: MISSED_STICKY,
|
|
UNSUPPORTED_Y: UNSUPPORTED_Y
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9160:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var global = __webpack_require__(5624);
|
|
|
|
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
|
|
var $RegExp = global.RegExp;
|
|
|
|
module.exports = fails(function () {
|
|
var re = $RegExp('.', 's');
|
|
return !(re.dotAll && re.test('\n') && re.flags === 's');
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7416:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var fails = __webpack_require__(6040);
|
|
var global = __webpack_require__(5624);
|
|
|
|
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
|
|
var $RegExp = global.RegExp;
|
|
|
|
module.exports = fails(function () {
|
|
var re = $RegExp('(?<a>b)', 'g');
|
|
return re.exec('b').groups.a !== 'b' ||
|
|
'b'.replace(re, '$<a>c') !== 'bc';
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2696:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var isNullOrUndefined = __webpack_require__(952);
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `RequireObjectCoercible` abstract operation
|
|
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
|
module.exports = function (it) {
|
|
if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
|
|
return it;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4200:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
|
|
module.exports = function (target, TAG, STATIC) {
|
|
if (target && !STATIC) target = target.prototype;
|
|
if (target && !hasOwn(target, TO_STRING_TAG)) {
|
|
defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8192:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var shared = __webpack_require__(8196);
|
|
var uid = __webpack_require__(320);
|
|
|
|
var keys = shared('keys');
|
|
|
|
module.exports = function (key) {
|
|
return keys[key] || (keys[key] = uid(key));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9136:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var defineGlobalProperty = __webpack_require__(1544);
|
|
|
|
var SHARED = '__core-js_shared__';
|
|
var store = global[SHARED] || defineGlobalProperty(SHARED, {});
|
|
|
|
module.exports = store;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8196:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var IS_PURE = __webpack_require__(2804);
|
|
var store = __webpack_require__(9136);
|
|
|
|
(module.exports = function (key, value) {
|
|
return store[key] || (store[key] = value !== undefined ? value : {});
|
|
})('versions', []).push({
|
|
version: '3.35.1',
|
|
mode: IS_PURE ? 'pure' : 'global',
|
|
copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
|
|
license: 'https://github.com/zloirock/core-js/blob/v3.35.1/LICENSE',
|
|
source: 'https://github.com/zloirock/core-js'
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1968:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var toIntegerOrInfinity = __webpack_require__(3288);
|
|
var toString = __webpack_require__(1992);
|
|
var requireObjectCoercible = __webpack_require__(2696);
|
|
|
|
var charAt = uncurryThis(''.charAt);
|
|
var charCodeAt = uncurryThis(''.charCodeAt);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
var createMethod = function (CONVERT_TO_STRING) {
|
|
return function ($this, pos) {
|
|
var S = toString(requireObjectCoercible($this));
|
|
var position = toIntegerOrInfinity(pos);
|
|
var size = S.length;
|
|
var first, second;
|
|
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
|
|
first = charCodeAt(S, position);
|
|
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|
|
|| (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
|
|
? CONVERT_TO_STRING
|
|
? charAt(S, position)
|
|
: first
|
|
: CONVERT_TO_STRING
|
|
? stringSlice(S, position, position + 2)
|
|
: (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
|
};
|
|
};
|
|
|
|
module.exports = {
|
|
// `String.prototype.codePointAt` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
|
|
codeAt: createMethod(false),
|
|
// `String.prototype.at` method
|
|
// https://github.com/mathiasbynens/String.prototype.at
|
|
charAt: createMethod(true)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1096:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var requireObjectCoercible = __webpack_require__(2696);
|
|
var toString = __webpack_require__(1992);
|
|
var whitespaces = __webpack_require__(3388);
|
|
|
|
var replace = uncurryThis(''.replace);
|
|
var ltrim = RegExp('^[' + whitespaces + ']+');
|
|
var rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');
|
|
|
|
// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
|
|
var createMethod = function (TYPE) {
|
|
return function ($this) {
|
|
var string = toString(requireObjectCoercible($this));
|
|
if (TYPE & 1) string = replace(string, ltrim, '');
|
|
if (TYPE & 2) string = replace(string, rtrim, '$1');
|
|
return string;
|
|
};
|
|
};
|
|
|
|
module.exports = {
|
|
// `String.prototype.{ trimLeft, trimStart }` methods
|
|
// https://tc39.es/ecma262/#sec-string.prototype.trimstart
|
|
start: createMethod(1),
|
|
// `String.prototype.{ trimRight, trimEnd }` methods
|
|
// https://tc39.es/ecma262/#sec-string.prototype.trimend
|
|
end: createMethod(2),
|
|
// `String.prototype.trim` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype.trim
|
|
trim: createMethod(3)
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8972:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable es/no-symbol -- required for testing */
|
|
var V8_VERSION = __webpack_require__(3356);
|
|
var fails = __webpack_require__(6040);
|
|
var global = __webpack_require__(5624);
|
|
|
|
var $String = global.String;
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
|
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
|
|
var symbol = Symbol('symbol detection');
|
|
// Chrome 38 Symbol has incorrect toString conversion
|
|
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
|
|
// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
|
|
// of course, fail.
|
|
return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
|
|
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
|
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4208:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(892);
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
|
|
module.exports = function () {
|
|
var Symbol = getBuiltIn('Symbol');
|
|
var SymbolPrototype = Symbol && Symbol.prototype;
|
|
var valueOf = SymbolPrototype && SymbolPrototype.valueOf;
|
|
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
|
|
|
if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) {
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
// eslint-disable-next-line no-unused-vars -- required for .length
|
|
defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function (hint) {
|
|
return call(valueOf, this);
|
|
}, { arity: 1 });
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4680:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
|
|
/* eslint-disable es/no-symbol -- safe */
|
|
module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4128:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
// `thisNumberValue` abstract operation
|
|
// https://tc39.es/ecma262/#sec-thisnumbervalue
|
|
module.exports = uncurryThis(1.0.valueOf);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4160:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIntegerOrInfinity = __webpack_require__(3288);
|
|
|
|
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 = toIntegerOrInfinity(index);
|
|
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9740:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// toObject with fallback for non-array-like ES3 strings
|
|
var IndexedObject = __webpack_require__(6212);
|
|
var requireObjectCoercible = __webpack_require__(2696);
|
|
|
|
module.exports = function (it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3288:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var trunc = __webpack_require__(1736);
|
|
|
|
// `ToIntegerOrInfinity` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
|
module.exports = function (argument) {
|
|
var number = +argument;
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
return number !== number || number === 0 ? 0 : trunc(number);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 960:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIntegerOrInfinity = __webpack_require__(3288);
|
|
|
|
var min = Math.min;
|
|
|
|
// `ToLength` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tolength
|
|
module.exports = function (argument) {
|
|
var len = toIntegerOrInfinity(argument);
|
|
return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6804:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var requireObjectCoercible = __webpack_require__(2696);
|
|
|
|
var $Object = Object;
|
|
|
|
// `ToObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toobject
|
|
module.exports = function (argument) {
|
|
return $Object(requireObjectCoercible(argument));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8176:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(892);
|
|
var isObject = __webpack_require__(808);
|
|
var isSymbol = __webpack_require__(6232);
|
|
var getMethod = __webpack_require__(364);
|
|
var ordinaryToPrimitive = __webpack_require__(7664);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var $TypeError = TypeError;
|
|
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
|
|
|
// `ToPrimitive` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toprimitive
|
|
module.exports = function (input, pref) {
|
|
if (!isObject(input) || isSymbol(input)) return input;
|
|
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
|
|
var result;
|
|
if (exoticToPrim) {
|
|
if (pref === undefined) pref = 'default';
|
|
result = call(exoticToPrim, input, pref);
|
|
if (!isObject(result) || isSymbol(result)) return result;
|
|
throw new $TypeError("Can't convert object to primitive value");
|
|
}
|
|
if (pref === undefined) pref = 'number';
|
|
return ordinaryToPrimitive(input, pref);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8732:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toPrimitive = __webpack_require__(8176);
|
|
var isSymbol = __webpack_require__(6232);
|
|
|
|
// `ToPropertyKey` abstract operation
|
|
// https://tc39.es/ecma262/#sec-topropertykey
|
|
module.exports = function (argument) {
|
|
var key = toPrimitive(argument, 'string');
|
|
return isSymbol(key) ? key : key + '';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1712:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var test = {};
|
|
|
|
test[TO_STRING_TAG] = 'z';
|
|
|
|
module.exports = String(test) === '[object z]';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1992:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var classof = __webpack_require__(8040);
|
|
|
|
var $String = String;
|
|
|
|
module.exports = function (argument) {
|
|
if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
|
|
return $String(argument);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4596:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
var $String = String;
|
|
|
|
module.exports = function (argument) {
|
|
try {
|
|
return $String(argument);
|
|
} catch (error) {
|
|
return 'Object';
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 320:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var uncurryThis = __webpack_require__(1447);
|
|
|
|
var id = 0;
|
|
var postfix = Math.random();
|
|
var toString = uncurryThis(1.0.toString);
|
|
|
|
module.exports = function (key) {
|
|
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9448:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable es/no-symbol -- required for testing */
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
|
|
module.exports = NATIVE_SYMBOL
|
|
&& !Symbol.sham
|
|
&& typeof Symbol.iterator == 'symbol';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4859:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var fails = __webpack_require__(6040);
|
|
|
|
// V8 ~ Chrome 36-
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
|
module.exports = DESCRIPTORS && fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
|
|
value: 42,
|
|
writable: false
|
|
}).prototype !== 42;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 280:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var isCallable = __webpack_require__(9063);
|
|
|
|
var WeakMap = global.WeakMap;
|
|
|
|
module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9635:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var path = __webpack_require__(4880);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var wrappedWellKnownSymbolModule = __webpack_require__(7732);
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
|
|
module.exports = function (NAME) {
|
|
var Symbol = path.Symbol || (path.Symbol = {});
|
|
if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
|
|
value: wrappedWellKnownSymbolModule.f(NAME)
|
|
});
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7732:
|
|
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
exports.f = wellKnownSymbol;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9459:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var shared = __webpack_require__(8196);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var uid = __webpack_require__(320);
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
var USE_SYMBOL_AS_UID = __webpack_require__(9448);
|
|
|
|
var Symbol = global.Symbol;
|
|
var WellKnownSymbolsStore = shared('wks');
|
|
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
|
|
|
|
module.exports = function (name) {
|
|
if (!hasOwn(WellKnownSymbolsStore, name)) {
|
|
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
|
|
? Symbol[name]
|
|
: createWellKnownSymbol('Symbol.' + name);
|
|
} return WellKnownSymbolsStore[name];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3388:
|
|
/***/ (function(module) {
|
|
|
|
"use strict";
|
|
|
|
// a string of all valid unicode whitespaces
|
|
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';
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5240:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var isPrototypeOf = __webpack_require__(6056);
|
|
var setPrototypeOf = __webpack_require__(5168);
|
|
var copyConstructorProperties = __webpack_require__(4304);
|
|
var proxyAccessor = __webpack_require__(9904);
|
|
var inheritIfRequired = __webpack_require__(2744);
|
|
var normalizeStringArgument = __webpack_require__(8659);
|
|
var installErrorCause = __webpack_require__(8712);
|
|
var installErrorStack = __webpack_require__(4736);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
|
|
module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
|
|
var STACK_TRACE_LIMIT = 'stackTraceLimit';
|
|
var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
|
|
var path = FULL_NAME.split('.');
|
|
var ERROR_NAME = path[path.length - 1];
|
|
var OriginalError = getBuiltIn.apply(null, path);
|
|
|
|
if (!OriginalError) return;
|
|
|
|
var OriginalErrorPrototype = OriginalError.prototype;
|
|
|
|
// V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
|
|
if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;
|
|
|
|
if (!FORCED) return OriginalError;
|
|
|
|
var BaseError = getBuiltIn('Error');
|
|
|
|
var WrappedError = wrapper(function (a, b) {
|
|
var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
|
|
var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
|
|
if (message !== undefined) createNonEnumerableProperty(result, 'message', message);
|
|
installErrorStack(result, WrappedError, result.stack, 2);
|
|
if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);
|
|
if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
|
|
return result;
|
|
});
|
|
|
|
WrappedError.prototype = OriginalErrorPrototype;
|
|
|
|
if (ERROR_NAME !== 'Error') {
|
|
if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);
|
|
else copyConstructorProperties(WrappedError, BaseError, { name: true });
|
|
} else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) {
|
|
proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);
|
|
proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');
|
|
}
|
|
|
|
copyConstructorProperties(WrappedError, OriginalError);
|
|
|
|
if (!IS_PURE) try {
|
|
// Safari 13- bug: WebAssembly errors does not have a proper `.name`
|
|
if (OriginalErrorPrototype.name !== ERROR_NAME) {
|
|
createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);
|
|
}
|
|
OriginalErrorPrototype.constructor = WrappedError;
|
|
} catch (error) { /* empty */ }
|
|
|
|
return WrappedError;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1956:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var $filter = (__webpack_require__(4904).filter);
|
|
var arrayMethodHasSpeciesSupport = __webpack_require__(7776);
|
|
|
|
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');
|
|
|
|
// `Array.prototype.filter` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.filter
|
|
// with adding support of @@species
|
|
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
|
|
filter: function filter(callbackfn /* , thisArg */) {
|
|
return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9120:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var addToUnscopables = __webpack_require__(2328);
|
|
var Iterators = __webpack_require__(4920);
|
|
var InternalStateModule = __webpack_require__(5444);
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
var defineIterator = __webpack_require__(8752);
|
|
var createIterResultObject = __webpack_require__(2596);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
|
|
var ARRAY_ITERATOR = 'Array Iterator';
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
|
|
|
|
// `Array.prototype.entries` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.entries
|
|
// `Array.prototype.keys` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.keys
|
|
// `Array.prototype.values` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.values
|
|
// `Array.prototype[@@iterator]` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
|
|
// `CreateArrayIterator` internal method
|
|
// https://tc39.es/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.es/ecma262/#sec-%arrayiteratorprototype%.next
|
|
}, function () {
|
|
var state = getInternalState(this);
|
|
var target = state.target;
|
|
var index = state.index++;
|
|
if (!target || index >= target.length) {
|
|
state.target = undefined;
|
|
return createIterResultObject(undefined, true);
|
|
}
|
|
switch (state.kind) {
|
|
case 'keys': return createIterResultObject(index, false);
|
|
case 'values': return createIterResultObject(target[index], false);
|
|
} return createIterResultObject([index, target[index]], false);
|
|
}, 'values');
|
|
|
|
// argumentsList[@@iterator] is %ArrayProto_values%
|
|
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
|
|
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
|
|
var values = Iterators.Arguments = Iterators.Array;
|
|
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
addToUnscopables('keys');
|
|
addToUnscopables('values');
|
|
addToUnscopables('entries');
|
|
|
|
// V8 ~ Chrome 45- bug
|
|
if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {
|
|
defineProperty(values, 'name', { value: 'values' });
|
|
} catch (error) { /* empty */ }
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6568:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var $map = (__webpack_require__(4904).map);
|
|
var arrayMethodHasSpeciesSupport = __webpack_require__(7776);
|
|
|
|
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
|
|
|
|
// `Array.prototype.map` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.map
|
|
// with adding support of @@species
|
|
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
|
|
map: function map(callbackfn /* , thisArg */) {
|
|
return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3248:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var toObject = __webpack_require__(6804);
|
|
var lengthOfArrayLike = __webpack_require__(9480);
|
|
var setArrayLength = __webpack_require__(7934);
|
|
var doesNotExceedSafeInteger = __webpack_require__(3272);
|
|
var fails = __webpack_require__(6040);
|
|
|
|
var INCORRECT_TO_LENGTH = fails(function () {
|
|
return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
|
|
});
|
|
|
|
// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=12681
|
|
var properErrorOnNonWritableLength = function () {
|
|
try {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty([], 'length', { writable: false }).push();
|
|
} catch (error) {
|
|
return error instanceof TypeError;
|
|
}
|
|
};
|
|
|
|
var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
|
|
|
|
// `Array.prototype.push` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.push
|
|
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
push: function push(item) {
|
|
var O = toObject(this);
|
|
var len = lengthOfArrayLike(O);
|
|
var argCount = arguments.length;
|
|
doesNotExceedSafeInteger(len + argCount);
|
|
for (var i = 0; i < argCount; i++) {
|
|
O[len] = arguments[i];
|
|
len++;
|
|
}
|
|
setArrayLength(O, len);
|
|
return len;
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7056:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var hasOwn = __webpack_require__(6216);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var dateToPrimitive = __webpack_require__(6268);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
|
var DatePrototype = Date.prototype;
|
|
|
|
// `Date.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive
|
|
if (!hasOwn(DatePrototype, TO_PRIMITIVE)) {
|
|
defineBuiltIn(DatePrototype, TO_PRIMITIVE, dateToPrimitive);
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2844:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
/* eslint-disable no-unused-vars -- required for functions `.length` */
|
|
var $ = __webpack_require__(3748);
|
|
var global = __webpack_require__(5624);
|
|
var apply = __webpack_require__(4744);
|
|
var wrapErrorConstructorWithCause = __webpack_require__(5240);
|
|
|
|
var WEB_ASSEMBLY = 'WebAssembly';
|
|
var WebAssembly = global[WEB_ASSEMBLY];
|
|
|
|
// eslint-disable-next-line es/no-error-cause -- feature detection
|
|
var FORCED = new Error('e', { cause: 7 }).cause !== 7;
|
|
|
|
var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
|
|
var O = {};
|
|
O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);
|
|
$({ global: true, constructor: true, arity: 1, forced: FORCED }, O);
|
|
};
|
|
|
|
var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
|
|
if (WebAssembly && WebAssembly[ERROR_NAME]) {
|
|
var O = {};
|
|
O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);
|
|
$({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);
|
|
}
|
|
};
|
|
|
|
// https://tc39.es/ecma262/#sec-nativeerror
|
|
exportGlobalErrorCauseWrapper('Error', function (init) {
|
|
return function Error(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('EvalError', function (init) {
|
|
return function EvalError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('RangeError', function (init) {
|
|
return function RangeError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
|
|
return function ReferenceError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
|
|
return function SyntaxError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('TypeError', function (init) {
|
|
return function TypeError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportGlobalErrorCauseWrapper('URIError', function (init) {
|
|
return function URIError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
|
|
return function CompileError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
|
|
return function LinkError(message) { return apply(init, this, arguments); };
|
|
});
|
|
exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
|
|
return function RuntimeError(message) { return apply(init, this, arguments); };
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6760:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var apply = __webpack_require__(4744);
|
|
var call = __webpack_require__(892);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var fails = __webpack_require__(6040);
|
|
var isCallable = __webpack_require__(9063);
|
|
var isSymbol = __webpack_require__(6232);
|
|
var arraySlice = __webpack_require__(7588);
|
|
var getReplacerFunction = __webpack_require__(6852);
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
|
|
var $String = String;
|
|
var $stringify = getBuiltIn('JSON', 'stringify');
|
|
var exec = uncurryThis(/./.exec);
|
|
var charAt = uncurryThis(''.charAt);
|
|
var charCodeAt = uncurryThis(''.charCodeAt);
|
|
var replace = uncurryThis(''.replace);
|
|
var numberToString = uncurryThis(1.0.toString);
|
|
|
|
var tester = /[\uD800-\uDFFF]/g;
|
|
var low = /^[\uD800-\uDBFF]$/;
|
|
var hi = /^[\uDC00-\uDFFF]$/;
|
|
|
|
var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function () {
|
|
var symbol = getBuiltIn('Symbol')('stringify detection');
|
|
// 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)) !== '{}';
|
|
});
|
|
|
|
// https://github.com/tc39/proposal-well-formed-stringify
|
|
var ILL_FORMED_UNICODE = fails(function () {
|
|
return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
|
|
|| $stringify('\uDEAD') !== '"\\udead"';
|
|
});
|
|
|
|
var stringifyWithSymbolsFix = function (it, replacer) {
|
|
var args = arraySlice(arguments);
|
|
var $replacer = getReplacerFunction(replacer);
|
|
if (!isCallable($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined
|
|
args[1] = function (key, value) {
|
|
// some old implementations (like WebKit) could pass numbers as keys
|
|
if (isCallable($replacer)) value = call($replacer, this, $String(key), value);
|
|
if (!isSymbol(value)) return value;
|
|
};
|
|
return apply($stringify, null, args);
|
|
};
|
|
|
|
var fixIllFormed = function (match, offset, string) {
|
|
var prev = charAt(string, offset - 1);
|
|
var next = charAt(string, offset + 1);
|
|
if ((exec(low, match) && !exec(hi, next)) || (exec(hi, match) && !exec(low, prev))) {
|
|
return '\\u' + numberToString(charCodeAt(match, 0), 16);
|
|
} return match;
|
|
};
|
|
|
|
if ($stringify) {
|
|
// `JSON.stringify` method
|
|
// https://tc39.es/ecma262/#sec-json.stringify
|
|
$({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE }, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
stringify: function stringify(it, replacer, space) {
|
|
var args = arraySlice(arguments);
|
|
var result = apply(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
|
|
return ILL_FORMED_UNICODE && typeof result == 'string' ? replace(result, tester, fixIllFormed) : result;
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9456:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var global = __webpack_require__(5624);
|
|
var path = __webpack_require__(4880);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var isForced = __webpack_require__(5272);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var inheritIfRequired = __webpack_require__(2744);
|
|
var isPrototypeOf = __webpack_require__(6056);
|
|
var isSymbol = __webpack_require__(6232);
|
|
var toPrimitive = __webpack_require__(8176);
|
|
var fails = __webpack_require__(6040);
|
|
var getOwnPropertyNames = (__webpack_require__(692).f);
|
|
var getOwnPropertyDescriptor = (__webpack_require__(4560).f);
|
|
var defineProperty = (__webpack_require__(368).f);
|
|
var thisNumberValue = __webpack_require__(4128);
|
|
var trim = (__webpack_require__(1096).trim);
|
|
|
|
var NUMBER = 'Number';
|
|
var NativeNumber = global[NUMBER];
|
|
var PureNumberNamespace = path[NUMBER];
|
|
var NumberPrototype = NativeNumber.prototype;
|
|
var TypeError = global.TypeError;
|
|
var stringSlice = uncurryThis(''.slice);
|
|
var charCodeAt = uncurryThis(''.charCodeAt);
|
|
|
|
// `ToNumeric` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tonumeric
|
|
var toNumeric = function (value) {
|
|
var primValue = toPrimitive(value, 'number');
|
|
return typeof primValue == 'bigint' ? primValue : toNumber(primValue);
|
|
};
|
|
|
|
// `ToNumber` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tonumber
|
|
var toNumber = function (argument) {
|
|
var it = toPrimitive(argument, 'number');
|
|
var first, third, radix, maxCode, digits, length, index, code;
|
|
if (isSymbol(it)) throw new TypeError('Cannot convert a Symbol value to a number');
|
|
if (typeof it == 'string' && it.length > 2) {
|
|
it = trim(it);
|
|
first = charCodeAt(it, 0);
|
|
if (first === 43 || first === 45) {
|
|
third = charCodeAt(it, 2);
|
|
if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
|
|
} else if (first === 48) {
|
|
switch (charCodeAt(it, 1)) {
|
|
// fast equal of /^0b[01]+$/i
|
|
case 66:
|
|
case 98:
|
|
radix = 2;
|
|
maxCode = 49;
|
|
break;
|
|
// fast equal of /^0o[0-7]+$/i
|
|
case 79:
|
|
case 111:
|
|
radix = 8;
|
|
maxCode = 55;
|
|
break;
|
|
default:
|
|
return +it;
|
|
}
|
|
digits = stringSlice(it, 2);
|
|
length = digits.length;
|
|
for (index = 0; index < length; index++) {
|
|
code = charCodeAt(digits, 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;
|
|
};
|
|
|
|
var FORCED = isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'));
|
|
|
|
var calledWithNew = function (dummy) {
|
|
// includes check on 1..constructor(foo) case
|
|
return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); });
|
|
};
|
|
|
|
// `Number` constructor
|
|
// https://tc39.es/ecma262/#sec-number-constructor
|
|
var NumberWrapper = function Number(value) {
|
|
var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
|
|
return calledWithNew(this) ? inheritIfRequired(Object(n), this, NumberWrapper) : n;
|
|
};
|
|
|
|
NumberWrapper.prototype = NumberPrototype;
|
|
if (FORCED && !IS_PURE) NumberPrototype.constructor = NumberWrapper;
|
|
|
|
$({ global: true, constructor: true, wrap: true, forced: FORCED }, {
|
|
Number: NumberWrapper
|
|
});
|
|
|
|
// Use `internal/copy-constructor-properties` helper in `core-js@4`
|
|
var copyConstructorProperties = function (target, source) {
|
|
for (var keys = DESCRIPTORS ? getOwnPropertyNames(source) : (
|
|
// ES3:
|
|
'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
|
|
// ES2015 (in case, if modules with ES2015 Number statics required before):
|
|
'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' +
|
|
// ESNext
|
|
'fromString,range'
|
|
).split(','), j = 0, key; keys.length > j; j++) {
|
|
if (hasOwn(source, key = keys[j]) && !hasOwn(target, key)) {
|
|
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
}
|
|
}
|
|
};
|
|
|
|
if (IS_PURE && PureNumberNamespace) copyConstructorProperties(path[NUMBER], PureNumberNamespace);
|
|
if (FORCED || IS_PURE) copyConstructorProperties(path[NUMBER], NativeNumber);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8235:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var assign = __webpack_require__(7048);
|
|
|
|
// `Object.assign` method
|
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
// eslint-disable-next-line es/no-object-assign -- required for testing
|
|
$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
|
|
assign: assign
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2600:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var fails = __webpack_require__(6040);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var nativeGetOwnPropertyDescriptor = (__webpack_require__(4560).f);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
|
|
var FORCED = !DESCRIPTORS || fails(function () { nativeGetOwnPropertyDescriptor(1); });
|
|
|
|
// `Object.getOwnPropertyDescriptor` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
|
$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, {
|
|
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) {
|
|
return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key);
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 4376:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var ownKeys = __webpack_require__(9976);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(4560);
|
|
var createProperty = __webpack_require__(8931);
|
|
|
|
// `Object.getOwnPropertyDescriptors` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
|
|
$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {
|
|
getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
|
|
var O = toIndexedObject(object);
|
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
var keys = ownKeys(O);
|
|
var result = {};
|
|
var index = 0;
|
|
var key, descriptor;
|
|
while (keys.length > index) {
|
|
descriptor = getOwnPropertyDescriptor(O, key = keys[index++]);
|
|
if (descriptor !== undefined) createProperty(result, key, descriptor);
|
|
}
|
|
return result;
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8728:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
var fails = __webpack_require__(6040);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(8167);
|
|
var toObject = __webpack_require__(6804);
|
|
|
|
// V8 ~ Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
|
|
var FORCED = !NATIVE_SYMBOL || fails(function () { getOwnPropertySymbolsModule.f(1); });
|
|
|
|
// `Object.getOwnPropertySymbols` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertysymbols
|
|
$({ target: 'Object', stat: true, forced: FORCED }, {
|
|
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
|
|
var $getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return $getOwnPropertySymbols ? $getOwnPropertySymbols(toObject(it)) : [];
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1040:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var toObject = __webpack_require__(6804);
|
|
var nativeKeys = __webpack_require__(4152);
|
|
var fails = __webpack_require__(6040);
|
|
|
|
var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
|
|
|
|
// `Object.keys` method
|
|
// https://tc39.es/ecma262/#sec-object.keys
|
|
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
|
|
keys: function keys(it) {
|
|
return nativeKeys(toObject(it));
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9640:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var TO_STRING_TAG_SUPPORT = __webpack_require__(1712);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var toString = __webpack_require__(3532);
|
|
|
|
// `Object.prototype.toString` method
|
|
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
|
if (!TO_STRING_TAG_SUPPORT) {
|
|
defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2644:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var exec = __webpack_require__(8096);
|
|
|
|
// `RegExp.prototype.exec` method
|
|
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
|
|
$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
|
|
exec: exec
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8928:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var charAt = (__webpack_require__(1968).charAt);
|
|
var toString = __webpack_require__(1992);
|
|
var InternalStateModule = __webpack_require__(5444);
|
|
var defineIterator = __webpack_require__(8752);
|
|
var createIterResultObject = __webpack_require__(2596);
|
|
|
|
var STRING_ITERATOR = 'String Iterator';
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
|
|
|
|
// `String.prototype[@@iterator]` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
|
|
defineIterator(String, 'String', function (iterated) {
|
|
setInternalState(this, {
|
|
type: STRING_ITERATOR,
|
|
string: toString(iterated),
|
|
index: 0
|
|
});
|
|
// `%StringIteratorPrototype%.next` method
|
|
// https://tc39.es/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 createIterResultObject(undefined, true);
|
|
point = charAt(string, index);
|
|
state.index += point.length;
|
|
return createIterResultObject(point, false);
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2888:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var call = __webpack_require__(892);
|
|
var fixRegExpWellKnownSymbolLogic = __webpack_require__(8760);
|
|
var anObject = __webpack_require__(8424);
|
|
var isNullOrUndefined = __webpack_require__(952);
|
|
var toLength = __webpack_require__(960);
|
|
var toString = __webpack_require__(1992);
|
|
var requireObjectCoercible = __webpack_require__(2696);
|
|
var getMethod = __webpack_require__(364);
|
|
var advanceStringIndex = __webpack_require__(6884);
|
|
var regExpExec = __webpack_require__(1456);
|
|
|
|
// @@match logic
|
|
fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) {
|
|
return [
|
|
// `String.prototype.match` method
|
|
// https://tc39.es/ecma262/#sec-string.prototype.match
|
|
function match(regexp) {
|
|
var O = requireObjectCoercible(this);
|
|
var matcher = isNullOrUndefined(regexp) ? undefined : getMethod(regexp, MATCH);
|
|
return matcher ? call(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString(O));
|
|
},
|
|
// `RegExp.prototype[@@match]` method
|
|
// https://tc39.es/ecma262/#sec-regexp.prototype-@@match
|
|
function (string) {
|
|
var rx = anObject(this);
|
|
var S = toString(string);
|
|
var res = maybeCallNative(nativeMatch, rx, S);
|
|
|
|
if (res.done) return res.value;
|
|
|
|
if (!rx.global) return regExpExec(rx, S);
|
|
|
|
var fullUnicode = rx.unicode;
|
|
rx.lastIndex = 0;
|
|
var A = [];
|
|
var n = 0;
|
|
var result;
|
|
while ((result = regExpExec(rx, S)) !== null) {
|
|
var matchStr = toString(result[0]);
|
|
A[n] = matchStr;
|
|
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
|
|
n++;
|
|
}
|
|
return n === 0 ? null : A;
|
|
}
|
|
];
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 8312:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var global = __webpack_require__(5624);
|
|
var call = __webpack_require__(892);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var IS_PURE = __webpack_require__(2804);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var NATIVE_SYMBOL = __webpack_require__(8972);
|
|
var fails = __webpack_require__(6040);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var isPrototypeOf = __webpack_require__(6056);
|
|
var anObject = __webpack_require__(8424);
|
|
var toIndexedObject = __webpack_require__(9740);
|
|
var toPropertyKey = __webpack_require__(8732);
|
|
var $toString = __webpack_require__(1992);
|
|
var createPropertyDescriptor = __webpack_require__(9200);
|
|
var nativeObjectCreate = __webpack_require__(8340);
|
|
var objectKeys = __webpack_require__(4152);
|
|
var getOwnPropertyNamesModule = __webpack_require__(692);
|
|
var getOwnPropertyNamesExternal = __webpack_require__(4856);
|
|
var getOwnPropertySymbolsModule = __webpack_require__(8167);
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(4560);
|
|
var definePropertyModule = __webpack_require__(368);
|
|
var definePropertiesModule = __webpack_require__(5045);
|
|
var propertyIsEnumerableModule = __webpack_require__(2460);
|
|
var defineBuiltIn = __webpack_require__(3244);
|
|
var defineBuiltInAccessor = __webpack_require__(1720);
|
|
var shared = __webpack_require__(8196);
|
|
var sharedKey = __webpack_require__(8192);
|
|
var hiddenKeys = __webpack_require__(6480);
|
|
var uid = __webpack_require__(320);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
var wrappedWellKnownSymbolModule = __webpack_require__(7732);
|
|
var defineWellKnownSymbol = __webpack_require__(9635);
|
|
var defineSymbolToPrimitive = __webpack_require__(4208);
|
|
var setToStringTag = __webpack_require__(4200);
|
|
var InternalStateModule = __webpack_require__(5444);
|
|
var $forEach = (__webpack_require__(4904).forEach);
|
|
|
|
var HIDDEN = sharedKey('hidden');
|
|
var SYMBOL = 'Symbol';
|
|
var PROTOTYPE = 'prototype';
|
|
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(SYMBOL);
|
|
|
|
var ObjectPrototype = Object[PROTOTYPE];
|
|
var $Symbol = global.Symbol;
|
|
var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE];
|
|
var RangeError = global.RangeError;
|
|
var TypeError = global.TypeError;
|
|
var QObject = global.QObject;
|
|
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
var nativeDefineProperty = definePropertyModule.f;
|
|
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
|
|
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
|
|
var push = uncurryThis([].push);
|
|
|
|
var AllSymbols = shared('symbols');
|
|
var ObjectPrototypeSymbols = shared('op-symbols');
|
|
var WellKnownSymbolsStore = shared('wks');
|
|
|
|
// 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 fallbackDefineProperty = 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);
|
|
}
|
|
};
|
|
|
|
var setSymbolDescriptor = DESCRIPTORS && fails(function () {
|
|
return nativeObjectCreate(nativeDefineProperty({}, 'a', {
|
|
get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }
|
|
})).a !== 7;
|
|
}) ? fallbackDefineProperty : nativeDefineProperty;
|
|
|
|
var wrap = function (tag, description) {
|
|
var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype);
|
|
setInternalState(symbol, {
|
|
type: SYMBOL,
|
|
tag: tag,
|
|
description: description
|
|
});
|
|
if (!DESCRIPTORS) symbol.description = description;
|
|
return symbol;
|
|
};
|
|
|
|
var $defineProperty = function defineProperty(O, P, Attributes) {
|
|
if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
|
|
anObject(O);
|
|
var key = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (hasOwn(AllSymbols, key)) {
|
|
if (!Attributes.enumerable) {
|
|
if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, nativeObjectCreate(null)));
|
|
O[HIDDEN][key] = true;
|
|
} else {
|
|
if (hasOwn(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 || call($propertyIsEnumerable, 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 = toPropertyKey(V);
|
|
var enumerable = call(nativePropertyIsEnumerable, this, P);
|
|
if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false;
|
|
return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P]
|
|
? enumerable : true;
|
|
};
|
|
|
|
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
|
|
var it = toIndexedObject(O);
|
|
var key = toPropertyKey(P);
|
|
if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return;
|
|
var descriptor = nativeGetOwnPropertyDescriptor(it, key);
|
|
if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(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 (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) push(result, key);
|
|
});
|
|
return result;
|
|
};
|
|
|
|
var $getOwnPropertySymbols = function (O) {
|
|
var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
|
|
var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
|
|
var result = [];
|
|
$forEach(names, function (key) {
|
|
if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {
|
|
push(result, AllSymbols[key]);
|
|
}
|
|
});
|
|
return result;
|
|
};
|
|
|
|
// `Symbol` constructor
|
|
// https://tc39.es/ecma262/#sec-symbol-constructor
|
|
if (!NATIVE_SYMBOL) {
|
|
$Symbol = function Symbol() {
|
|
if (isPrototypeOf(SymbolPrototype, this)) throw new TypeError('Symbol is not a constructor');
|
|
var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);
|
|
var tag = uid(description);
|
|
var setter = function (value) {
|
|
var $this = this === undefined ? global : this;
|
|
if ($this === ObjectPrototype) call(setter, ObjectPrototypeSymbols, value);
|
|
if (hasOwn($this, HIDDEN) && hasOwn($this[HIDDEN], tag)) $this[HIDDEN][tag] = false;
|
|
var descriptor = createPropertyDescriptor(1, value);
|
|
try {
|
|
setSymbolDescriptor($this, tag, descriptor);
|
|
} catch (error) {
|
|
if (!(error instanceof RangeError)) throw error;
|
|
fallbackDefineProperty($this, tag, descriptor);
|
|
}
|
|
};
|
|
if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
|
|
return wrap(tag, description);
|
|
};
|
|
|
|
SymbolPrototype = $Symbol[PROTOTYPE];
|
|
|
|
defineBuiltIn(SymbolPrototype, 'toString', function toString() {
|
|
return getInternalState(this).tag;
|
|
});
|
|
|
|
defineBuiltIn($Symbol, 'withoutSetter', function (description) {
|
|
return wrap(uid(description), description);
|
|
});
|
|
|
|
propertyIsEnumerableModule.f = $propertyIsEnumerable;
|
|
definePropertyModule.f = $defineProperty;
|
|
definePropertiesModule.f = $defineProperties;
|
|
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
|
|
defineBuiltInAccessor(SymbolPrototype, 'description', {
|
|
configurable: true,
|
|
get: function description() {
|
|
return getInternalState(this).description;
|
|
}
|
|
});
|
|
if (!IS_PURE) {
|
|
defineBuiltIn(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
|
|
}
|
|
}
|
|
}
|
|
|
|
$({ global: true, constructor: 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 }, {
|
|
useSetter: function () { USE_SETTER = true; },
|
|
useSimple: function () { USE_SETTER = false; }
|
|
});
|
|
|
|
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {
|
|
// `Object.create` method
|
|
// https://tc39.es/ecma262/#sec-object.create
|
|
create: $create,
|
|
// `Object.defineProperty` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
defineProperty: $defineProperty,
|
|
// `Object.defineProperties` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperties
|
|
defineProperties: $defineProperties,
|
|
// `Object.getOwnPropertyDescriptor` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
|
|
getOwnPropertyDescriptor: $getOwnPropertyDescriptor
|
|
});
|
|
|
|
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {
|
|
// `Object.getOwnPropertyNames` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertynames
|
|
getOwnPropertyNames: $getOwnPropertyNames
|
|
});
|
|
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
defineSymbolToPrimitive();
|
|
|
|
// `Symbol.prototype[@@toStringTag]` property
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
|
|
setToStringTag($Symbol, SYMBOL);
|
|
|
|
hiddenKeys[HIDDEN] = true;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5016:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
// `Symbol.prototype.description` getter
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype.description
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var DESCRIPTORS = __webpack_require__(3528);
|
|
var global = __webpack_require__(5624);
|
|
var uncurryThis = __webpack_require__(1447);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var isCallable = __webpack_require__(9063);
|
|
var isPrototypeOf = __webpack_require__(6056);
|
|
var toString = __webpack_require__(1992);
|
|
var defineBuiltInAccessor = __webpack_require__(1720);
|
|
var copyConstructorProperties = __webpack_require__(4304);
|
|
|
|
var NativeSymbol = global.Symbol;
|
|
var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
|
|
|
|
if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) ||
|
|
// 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 : toString(arguments[0]);
|
|
var result = isPrototypeOf(SymbolPrototype, this)
|
|
? 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);
|
|
SymbolWrapper.prototype = SymbolPrototype;
|
|
SymbolPrototype.constructor = SymbolWrapper;
|
|
|
|
var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
|
|
var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf);
|
|
var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString);
|
|
var regexp = /^Symbol\((.*)\)[^)]+$/;
|
|
var replace = uncurryThis(''.replace);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
defineBuiltInAccessor(SymbolPrototype, 'description', {
|
|
configurable: true,
|
|
get: function description() {
|
|
var symbol = thisSymbolValue(this);
|
|
if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
|
|
var string = symbolDescriptiveString(symbol);
|
|
var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
|
|
return desc === '' ? undefined : desc;
|
|
}
|
|
});
|
|
|
|
$({ global: true, constructor: true, forced: true }, {
|
|
Symbol: SymbolWrapper
|
|
});
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5256:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var getBuiltIn = __webpack_require__(4960);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var toString = __webpack_require__(1992);
|
|
var shared = __webpack_require__(8196);
|
|
var NATIVE_SYMBOL_REGISTRY = __webpack_require__(4680);
|
|
|
|
var StringToSymbolRegistry = shared('string-to-symbol-registry');
|
|
var SymbolToStringRegistry = shared('symbol-to-string-registry');
|
|
|
|
// `Symbol.for` method
|
|
// https://tc39.es/ecma262/#sec-symbol.for
|
|
$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, {
|
|
'for': function (key) {
|
|
var string = toString(key);
|
|
if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
|
|
var symbol = getBuiltIn('Symbol')(string);
|
|
StringToSymbolRegistry[string] = symbol;
|
|
SymbolToStringRegistry[symbol] = string;
|
|
return symbol;
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6968:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(9635);
|
|
|
|
// `Symbol.iterator` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.iterator
|
|
defineWellKnownSymbol('iterator');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3475:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// TODO: Remove this module from `core-js@4` since it's split to modules listed below
|
|
__webpack_require__(8312);
|
|
__webpack_require__(5256);
|
|
__webpack_require__(1352);
|
|
__webpack_require__(6760);
|
|
__webpack_require__(8728);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1352:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var $ = __webpack_require__(3748);
|
|
var hasOwn = __webpack_require__(6216);
|
|
var isSymbol = __webpack_require__(6232);
|
|
var tryToString = __webpack_require__(4596);
|
|
var shared = __webpack_require__(8196);
|
|
var NATIVE_SYMBOL_REGISTRY = __webpack_require__(4680);
|
|
|
|
var SymbolToStringRegistry = shared('symbol-to-string-registry');
|
|
|
|
// `Symbol.keyFor` method
|
|
// https://tc39.es/ecma262/#sec-symbol.keyfor
|
|
$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, {
|
|
keyFor: function keyFor(sym) {
|
|
if (!isSymbol(sym)) throw new TypeError(tryToString(sym) + ' is not a symbol');
|
|
if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
|
|
}
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 1668:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var defineWellKnownSymbol = __webpack_require__(9635);
|
|
var defineSymbolToPrimitive = __webpack_require__(4208);
|
|
|
|
// `Symbol.toPrimitive` well-known symbol
|
|
// https://tc39.es/ecma262/#sec-symbol.toprimitive
|
|
defineWellKnownSymbol('toPrimitive');
|
|
|
|
// `Symbol.prototype[@@toPrimitive]` method
|
|
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
|
|
defineSymbolToPrimitive();
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2984:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var DOMIterables = __webpack_require__(5848);
|
|
var DOMTokenListPrototype = __webpack_require__(8280);
|
|
var forEach = __webpack_require__(5935);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
|
|
var handlePrototype = function (CollectionPrototype) {
|
|
// some Chrome versions have non-configurable methods on DOMTokenList
|
|
if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {
|
|
createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);
|
|
} catch (error) {
|
|
CollectionPrototype.forEach = forEach;
|
|
}
|
|
};
|
|
|
|
for (var COLLECTION_NAME in DOMIterables) {
|
|
if (DOMIterables[COLLECTION_NAME]) {
|
|
handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);
|
|
}
|
|
}
|
|
|
|
handlePrototype(DOMTokenListPrototype);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 9708:
|
|
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
var global = __webpack_require__(5624);
|
|
var DOMIterables = __webpack_require__(5848);
|
|
var DOMTokenListPrototype = __webpack_require__(8280);
|
|
var ArrayIteratorMethods = __webpack_require__(9120);
|
|
var createNonEnumerableProperty = __webpack_require__(3652);
|
|
var setToStringTag = __webpack_require__(4200);
|
|
var wellKnownSymbol = __webpack_require__(9459);
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var ArrayValues = ArrayIteratorMethods.values;
|
|
|
|
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
|
|
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;
|
|
}
|
|
setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
|
|
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];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
for (var COLLECTION_NAME in DOMIterables) {
|
|
handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);
|
|
}
|
|
|
|
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3996:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
var toPropertyKey = __webpack_require__(5668);
|
|
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;
|
|
}
|
|
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2916:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
__webpack_require__(3475);
|
|
__webpack_require__(1956);
|
|
__webpack_require__(3248);
|
|
__webpack_require__(2600);
|
|
__webpack_require__(4376);
|
|
__webpack_require__(1040);
|
|
__webpack_require__(9640);
|
|
__webpack_require__(2984);
|
|
var defineProperty = __webpack_require__(3996);
|
|
function ownKeys(e, r) {
|
|
var t = Object.keys(e);
|
|
if (Object.getOwnPropertySymbols) {
|
|
var o = Object.getOwnPropertySymbols(e);
|
|
r && (o = o.filter(function (r) {
|
|
return Object.getOwnPropertyDescriptor(e, r).enumerable;
|
|
})), t.push.apply(t, o);
|
|
}
|
|
return t;
|
|
}
|
|
function _objectSpread2(e) {
|
|
for (var r = 1; r < arguments.length; r++) {
|
|
var t = null != arguments[r] ? arguments[r] : {};
|
|
r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
|
|
defineProperty(e, r, t[r]);
|
|
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
|
|
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
|
|
});
|
|
}
|
|
return e;
|
|
}
|
|
module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 7956:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
__webpack_require__(3475);
|
|
__webpack_require__(5016);
|
|
__webpack_require__(1668);
|
|
__webpack_require__(2844);
|
|
__webpack_require__(7056);
|
|
__webpack_require__(9456);
|
|
__webpack_require__(9640);
|
|
var _typeof = (__webpack_require__(6432)["default"]);
|
|
function toPrimitive(t, r) {
|
|
if ("object" != _typeof(t) || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r || "default");
|
|
if ("object" != _typeof(i)) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return ("string" === r ? String : Number)(t);
|
|
}
|
|
module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5668:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
var _typeof = (__webpack_require__(6432)["default"]);
|
|
var toPrimitive = __webpack_require__(7956);
|
|
function toPropertyKey(t) {
|
|
var i = toPrimitive(t, "string");
|
|
return "symbol" == _typeof(i) ? i : String(i);
|
|
}
|
|
module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6432:
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
__webpack_require__(3475);
|
|
__webpack_require__(5016);
|
|
__webpack_require__(6968);
|
|
__webpack_require__(9120);
|
|
__webpack_require__(9640);
|
|
__webpack_require__(8928);
|
|
__webpack_require__(9708);
|
|
function _typeof(o) {
|
|
"@babel/helpers - typeof";
|
|
|
|
return (module.exports = _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;
|
|
}, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(o);
|
|
}
|
|
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
/************************************************************************/
|
|
/******/ // The module cache
|
|
/******/ var __webpack_module_cache__ = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/ // Check if module is in cache
|
|
/******/ var cachedModule = __webpack_module_cache__[moduleId];
|
|
/******/ if (cachedModule !== undefined) {
|
|
/******/ return cachedModule.exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = __webpack_module_cache__[moduleId] = {
|
|
/******/ id: moduleId,
|
|
/******/ // no module.loaded needed
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/************************************************************************/
|
|
/******/ /* webpack/runtime/compat get default export */
|
|
/******/ !function() {
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function() { return module['default']; } :
|
|
/******/ function() { return module; };
|
|
/******/ __webpack_require__.d(getter, { a: getter });
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/define property getters */
|
|
/******/ !function() {
|
|
/******/ // define getter functions for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, definition) {
|
|
/******/ for(var key in definition) {
|
|
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
|
|
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
|
|
/******/ }
|
|
/******/ }
|
|
/******/ };
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/global */
|
|
/******/ !function() {
|
|
/******/ __webpack_require__.g = (function() {
|
|
/******/ if (typeof globalThis === 'object') return globalThis;
|
|
/******/ try {
|
|
/******/ return this || new Function('return this')();
|
|
/******/ } catch (e) {
|
|
/******/ if (typeof window === 'object') return window;
|
|
/******/ }
|
|
/******/ })();
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/hasOwnProperty shorthand */
|
|
/******/ !function() {
|
|
/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/make namespace object */
|
|
/******/ !function() {
|
|
/******/ // 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 });
|
|
/******/ };
|
|
/******/ }();
|
|
/******/
|
|
/******/ /* webpack/runtime/publicPath */
|
|
/******/ !function() {
|
|
/******/ __webpack_require__.p = "";
|
|
/******/ }();
|
|
/******/
|
|
/************************************************************************/
|
|
var __webpack_exports__ = {};
|
|
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
|
|
!function() {
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"default": function() { return /* binding */ entry_lib; }
|
|
});
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
|
|
/* eslint-disable no-var */
|
|
// This file is imported into lib/wc client bundles.
|
|
|
|
if (typeof window !== 'undefined') {
|
|
var currentScript = window.document.currentScript
|
|
if (true) {
|
|
var getCurrentScript = __webpack_require__(448)
|
|
currentScript = getCurrentScript()
|
|
|
|
// for backward compatibility, because previously we directly included the polyfill
|
|
if (!('currentScript' in document)) {
|
|
Object.defineProperty(document, 'currentScript', { get: getCurrentScript })
|
|
}
|
|
}
|
|
|
|
var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
|
|
if (src) {
|
|
__webpack_require__.p = src[1] // eslint-disable-line
|
|
}
|
|
}
|
|
|
|
// Indicate to webpack that this file can be concatenated
|
|
/* harmony default export */ var setPublicPath = (null);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.exec.js
|
|
var es_regexp_exec = __webpack_require__(2644);
|
|
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.string.match.js
|
|
var es_string_match = __webpack_require__(2888);
|
|
;// CONCATENATED MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
|
|
var external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject = require("vue");
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/Bracket.vue?vue&type=template&id=23a3a63f
|
|
|
|
|
|
|
|
var _hoisted_1 = {
|
|
key: 0,
|
|
class: "vtb-wrapper"
|
|
};
|
|
function render(_ctx, _cache, $props, $setup, $data, $options) {
|
|
var _component_bracket_node = (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.resolveComponent)("bracket-node");
|
|
return $options.recursiveBracket ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", _hoisted_1, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createVNode)(_component_bracket_node, {
|
|
"bracket-node": $options.recursiveBracket,
|
|
onOnSelectedPlayer: $options.highlightPlayer,
|
|
onOnDeselectedPlayer: $options.unhighlightPlayer,
|
|
"highlighted-player-id": $data.highlightedPlayerId
|
|
}, {
|
|
player: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref) {
|
|
var player = _ref.player;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: player
|
|
})];
|
|
}),
|
|
"player-extension-bottom": (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref2) {
|
|
var match = _ref2.match;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player-extension-bottom", {
|
|
match: match
|
|
})];
|
|
}),
|
|
_: 3
|
|
}, 8, ["bracket-node", "onOnSelectedPlayer", "onOnDeselectedPlayer", "highlighted-player-id"])])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createCommentVNode)("", true);
|
|
}
|
|
;// CONCATENATED MODULE: ./src/Bracket.vue?vue&type=template&id=23a3a63f
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/BracketNode.vue?vue&type=template&id=3c68116a
|
|
|
|
|
|
|
|
var BracketNodevue_type_template_id_3c68116a_hoisted_1 = {
|
|
key: 0,
|
|
class: "vtb-item"
|
|
};
|
|
var _hoisted_2 = {
|
|
key: 0,
|
|
class: "vtb-item-children"
|
|
};
|
|
var _hoisted_3 = {
|
|
key: 0,
|
|
class: "vtb-item-child"
|
|
};
|
|
var _hoisted_4 = {
|
|
key: 1,
|
|
class: "vtb-item-child"
|
|
};
|
|
function BracketNodevue_type_template_id_3c68116a_render(_ctx, _cache, $props, $setup, $data, $options) {
|
|
var _component_game_players = (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.resolveComponent)("game-players");
|
|
var _component_bracket_node = (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.resolveComponent)("bracket-node", true);
|
|
return $options.playersArePresent ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", BracketNodevue_type_template_id_3c68116a_hoisted_1, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementVNode)("div", {
|
|
class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.normalizeClass)($options.getBracketNodeClass($props.bracketNode))
|
|
}, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createVNode)(_component_game_players, {
|
|
"bracket-node": $props.bracketNode,
|
|
"highlighted-player-id": $props.highlightedPlayerId,
|
|
onOnSelectedPlayer: $options.highlightPlayer,
|
|
onOnDeselectedPlayer: $options.unhighlightPlayer
|
|
}, {
|
|
player: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref) {
|
|
var player = _ref.player;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: player
|
|
})];
|
|
}),
|
|
"player-extension-bottom": (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref2) {
|
|
var match = _ref2.match;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player-extension-bottom", {
|
|
match: match
|
|
})];
|
|
}),
|
|
_: 3
|
|
}, 8, ["bracket-node", "highlighted-player-id", "onOnSelectedPlayer", "onOnDeselectedPlayer"])], 2), $props.bracketNode.games[0] || $props.bracketNode.games[1] ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", _hoisted_2, [$props.bracketNode.games[0] ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", _hoisted_3, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createVNode)(_component_bracket_node, {
|
|
"bracket-node": $props.bracketNode.games[0],
|
|
"highlighted-player-id": $props.highlightedPlayerId,
|
|
onOnSelectedPlayer: $options.highlightPlayer,
|
|
onOnDeselectedPlayer: $options.unhighlightPlayer
|
|
}, {
|
|
player: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref3) {
|
|
var player = _ref3.player;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: player
|
|
})];
|
|
}),
|
|
"player-extension-bottom": (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref4) {
|
|
var match = _ref4.match;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player-extension-bottom", {
|
|
match: match
|
|
})];
|
|
}),
|
|
_: 3
|
|
}, 8, ["bracket-node", "highlighted-player-id", "onOnSelectedPlayer", "onOnDeselectedPlayer"])])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createCommentVNode)("", true), $props.bracketNode.games[1] ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", _hoisted_4, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createVNode)(_component_bracket_node, {
|
|
"bracket-node": $props.bracketNode.games[1],
|
|
"highlighted-player-id": $props.highlightedPlayerId,
|
|
onOnSelectedPlayer: $options.highlightPlayer,
|
|
onOnDeselectedPlayer: $options.unhighlightPlayer
|
|
}, {
|
|
player: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref5) {
|
|
var player = _ref5.player;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: player
|
|
})];
|
|
}),
|
|
"player-extension-bottom": (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.withCtx)(function (_ref6) {
|
|
var match = _ref6.match;
|
|
return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player-extension-bottom", {
|
|
match: match
|
|
})];
|
|
}),
|
|
_: 3
|
|
}, 8, ["bracket-node", "highlighted-player-id", "onOnSelectedPlayer", "onOnDeselectedPlayer"])])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createCommentVNode)("", true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createCommentVNode)("", true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createCommentVNode)("", true);
|
|
}
|
|
;// CONCATENATED MODULE: ./src/components/BracketNode.vue?vue&type=template&id=3c68116a
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/GamePlayers.vue?vue&type=template&id=26117be4
|
|
|
|
var GamePlayersvue_type_template_id_26117be4_hoisted_1 = {
|
|
class: "vtb-item-players"
|
|
};
|
|
function GamePlayersvue_type_template_id_26117be4_render(_ctx, _cache, $props, $setup, $data, $options) {
|
|
return (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementBlock)("div", GamePlayersvue_type_template_id_26117be4_hoisted_1, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementVNode)("div", null, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementVNode)("div", {
|
|
class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.normalizeClass)(['vtb-player', 'vtb-player1', $options.getPlayerClass($props.bracketNode.player1)]),
|
|
onMouseover: _cache[0] || (_cache[0] = function ($event) {
|
|
return $options.highlightPlayer($props.bracketNode.player1.id);
|
|
}),
|
|
onMouseleave: _cache[1] || (_cache[1] = function () {
|
|
return $options.unhighlightPlayer && $options.unhighlightPlayer.apply($options, arguments);
|
|
})
|
|
}, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: $props.bracketNode.player1
|
|
})], 34), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.createElementVNode)("div", {
|
|
class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.normalizeClass)(['vtb-player', 'vtb-player2', $options.getPlayerClass($props.bracketNode.player2)]),
|
|
onMouseover: _cache[2] || (_cache[2] = function ($event) {
|
|
return $options.highlightPlayer($props.bracketNode.player2.id);
|
|
}),
|
|
onMouseleave: _cache[3] || (_cache[3] = function () {
|
|
return $options.unhighlightPlayer && $options.unhighlightPlayer.apply($options, arguments);
|
|
})
|
|
}, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player", {
|
|
player: $props.bracketNode.player2
|
|
})], 34)]), (0,external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject.renderSlot)(_ctx.$slots, "player-extension-bottom", {
|
|
match: $options.matchProperties
|
|
})]);
|
|
}
|
|
;// CONCATENATED MODULE: ./src/components/GamePlayers.vue?vue&type=template&id=26117be4
|
|
|
|
// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.assign.js
|
|
var es_object_assign = __webpack_require__(8235);
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/GamePlayers.vue?vue&type=script&lang=js
|
|
|
|
/* harmony default export */ var GamePlayersvue_type_script_lang_js = ({
|
|
name: "game-players",
|
|
props: ["bracketNode", "highlightedPlayerId"],
|
|
computed: {
|
|
matchProperties: function matchProperties() {
|
|
return Object.assign({}, this.bracketNode, {
|
|
games: undefined,
|
|
hasParent: undefined
|
|
});
|
|
}
|
|
},
|
|
methods: {
|
|
getPlayerClass: function getPlayerClass(player) {
|
|
if (player.winner === null || player.winner === undefined) {
|
|
return "";
|
|
}
|
|
var clazz = player.winner ? "winner" : "defeated";
|
|
if (this.highlightedPlayerId === player.id) {
|
|
clazz += " highlight";
|
|
}
|
|
return clazz;
|
|
},
|
|
highlightPlayer: function highlightPlayer(playerId) {
|
|
this.$emit("onSelectedPlayer", playerId);
|
|
},
|
|
unhighlightPlayer: function unhighlightPlayer() {
|
|
this.$emit("onDeselectedPlayer");
|
|
}
|
|
}
|
|
});
|
|
;// CONCATENATED MODULE: ./src/components/GamePlayers.vue?vue&type=script&lang=js
|
|
|
|
// EXTERNAL MODULE: ./node_modules/vue-loader/dist/exportHelper.js
|
|
var exportHelper = __webpack_require__(8152);
|
|
;// CONCATENATED MODULE: ./src/components/GamePlayers.vue
|
|
|
|
|
|
|
|
|
|
;
|
|
const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.c)(GamePlayersvue_type_script_lang_js, [['render',GamePlayersvue_type_template_id_26117be4_render]])
|
|
|
|
/* harmony default export */ var GamePlayers = (__exports__);
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/BracketNode.vue?vue&type=script&lang=js
|
|
|
|
/* harmony default export */ var BracketNodevue_type_script_lang_js = ({
|
|
name: "bracket-node",
|
|
components: {
|
|
GamePlayers: GamePlayers
|
|
},
|
|
props: ["bracketNode", "highlightedPlayerId"],
|
|
computed: {
|
|
playersArePresent: function playersArePresent() {
|
|
return this.bracketNode.player1 && this.bracketNode.player1;
|
|
}
|
|
},
|
|
methods: {
|
|
getBracketNodeClass: function getBracketNodeClass(bracketNode) {
|
|
if (bracketNode.games[0] || bracketNode.games[1]) {
|
|
return "vtb-item-parent";
|
|
}
|
|
if (bracketNode.hasParent) {
|
|
return "vtb-item-child";
|
|
}
|
|
return "";
|
|
},
|
|
getPlayerClass: function getPlayerClass(player) {
|
|
if (player.winner === null || player.winner === undefined) {
|
|
return "";
|
|
}
|
|
var clazz = player.winner ? "winner" : "defeated";
|
|
if (this.highlightedPlayerId === player.id) {
|
|
clazz += " highlight";
|
|
}
|
|
return clazz;
|
|
},
|
|
highlightPlayer: function highlightPlayer(playerId) {
|
|
this.$emit("onSelectedPlayer", playerId);
|
|
},
|
|
unhighlightPlayer: function unhighlightPlayer() {
|
|
this.$emit("onDeselectedPlayer");
|
|
}
|
|
}
|
|
});
|
|
;// CONCATENATED MODULE: ./src/components/BracketNode.vue?vue&type=script&lang=js
|
|
|
|
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js??clonedRuleSet-12.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-12.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-12.use[2]!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-12.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/BracketNode.vue?vue&type=style&index=0&id=3c68116a&lang=css
|
|
var BracketNodevue_type_style_index_0_id_3c68116a_lang_css = __webpack_require__(4216);
|
|
;// CONCATENATED MODULE: ./src/components/BracketNode.vue?vue&type=style&index=0&id=3c68116a&lang=css
|
|
|
|
;// CONCATENATED MODULE: ./src/components/BracketNode.vue
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
|
|
const BracketNode_exports_ = /*#__PURE__*/(0,exportHelper/* default */.c)(BracketNodevue_type_script_lang_js, [['render',BracketNodevue_type_template_id_3c68116a_render]])
|
|
|
|
/* harmony default export */ var BracketNode = (BracketNode_exports_);
|
|
// EXTERNAL MODULE: ./src/components/recursiveBracket.js
|
|
var components_recursiveBracket = __webpack_require__(5796);
|
|
var recursiveBracket_default = /*#__PURE__*/__webpack_require__.n(components_recursiveBracket);
|
|
;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/Bracket.vue?vue&type=script&lang=js
|
|
|
|
|
|
/* harmony default export */ var Bracketvue_type_script_lang_js = ({
|
|
name: "bracket",
|
|
components: {
|
|
"bracket-node": BracketNode
|
|
},
|
|
props: ["rounds", "flatTree"],
|
|
data: function data() {
|
|
return {
|
|
highlightedPlayerId: null
|
|
};
|
|
},
|
|
computed: {
|
|
recursiveBracket: function recursiveBracket() {
|
|
if (this.flatTree) {
|
|
return recursiveBracket_default().transformFlatTree(this.flatTree);
|
|
}
|
|
return recursiveBracket_default().transform(this.rounds);
|
|
}
|
|
},
|
|
methods: {
|
|
highlightPlayer: function highlightPlayer(id) {
|
|
this.highlightedPlayerId = id;
|
|
},
|
|
unhighlightPlayer: function unhighlightPlayer() {
|
|
this.highlightedPlayerId = null;
|
|
}
|
|
}
|
|
});
|
|
;// CONCATENATED MODULE: ./src/Bracket.vue?vue&type=script&lang=js
|
|
|
|
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js??clonedRuleSet-12.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-12.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-12.use[2]!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-12.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/Bracket.vue?vue&type=style&index=0&id=23a3a63f&lang=css
|
|
var Bracketvue_type_style_index_0_id_23a3a63f_lang_css = __webpack_require__(2142);
|
|
;// CONCATENATED MODULE: ./src/Bracket.vue?vue&type=style&index=0&id=23a3a63f&lang=css
|
|
|
|
;// CONCATENATED MODULE: ./src/Bracket.vue
|
|
|
|
|
|
|
|
|
|
;
|
|
|
|
|
|
const Bracket_exports_ = /*#__PURE__*/(0,exportHelper/* default */.c)(Bracketvue_type_script_lang_js, [['render',render]])
|
|
|
|
/* harmony default export */ var Bracket = (Bracket_exports_);
|
|
;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js
|
|
|
|
|
|
/* harmony default export */ var entry_lib = (Bracket);
|
|
|
|
|
|
}();
|
|
module.exports = __webpack_exports__["default"];
|
|
/******/ })()
|
|
;
|
|
//# sourceMappingURL=vue-tournament-bracket.common.js.map
|