vendor: 3,174 bytes, lines 1-113
1(self["webpackChunkfreebox"] = self["webpackChunkfreebox"] || []).push([[998],{ 2 3/***/ 3736: 4/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5 6"use strict"; 7/* harmony export */ __webpack_require__.d(__webpack_exports__, { 8/* harmony export */ Z: function() { return /* binding */ normalizeComponent; } 9/* harmony export */ }); 10/* globals __VUE_SSR_CONTEXT__ */ 11 12// IMPORTANT: Do NOT use ES2015 features in this file (except for modules). 13// This module is a runtime utility for cleaner component module output and will 14// be included in the final webpack user bundle. 15 16function normalizeComponent( 17 scriptExports, 18 render, 19 staticRenderFns, 20 functionalTemplate, 21 injectStyles, 22 scopeId, 23 moduleIdentifier /* server only */, 24 shadowMode /* vue-cli only */ 25) { 26 // Vue.extend constructor export interop 27 var options = 28 typeof scriptExports === 'function' ? scriptExports.options : scriptExports 29 30 // render functions 31 if (render) { 32 options.render = render 33 options.staticRenderFns = staticRenderFns 34 options._compiled = true 35 } 36 37 // functional template 38 if (functionalTemplate) { 39 options.functional = true 40 } 41 42 // scopedId 43 if (scopeId) { 44 options._scopeId = 'data-v-' + scopeId 45 } 46 47 var hook 48 if (moduleIdentifier) { 49 // server build 50 hook = function (context) { 51 // 2.3 injection 52 context = 53 context || // cached call 54 (this.$vnode && this.$vnode.ssrContext) || // stateful 55 (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional 56 // 2.2 with runInNewContext: true 57 if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') { 58 context = __VUE_SSR_CONTEXT__ 59 } 60 // inject component styles 61 if (injectStyles) { 62 injectStyles.call(this, context) 63 } 64 // register component module identifier for async chunk inferrence 65 if (context && context._registeredComponents) { 66 context._registeredComponents.add(moduleIdentifier) 67 } 68 } 69 // used by ssr in case component is cached and beforeCreate 70 // never gets called 71 options._ssrRegister = hook 72 } else if (injectStyles) { 73 hook = shadowMode 74 ? function () { 75 injectStyles.call( 76 this, 77 (options.functional ? this.parent : this).$root.$options.shadowRoot 78 ) 79 } 80 : injectStyles 81 } 82 83 if (hook) { 84 if (options.functional) { 85 // for template-only hot-reload because in that case the render fn doesn't 86 // go through the normalizer 87 options._injectStyles = hook 88 // register for functional component in vue file 89 var originalRender = options.render 90 options.render = function renderWithStyleInjection(h, context) { 91 hook.call(context) 92 return originalRender(h, context) 93 } 94 } else { 95 // inject component registration as beforeCreate hook 96 var existing = options.beforeCreate 97 options.beforeCreate = existing ? [].concat(existing, hook) : [hook] 98 } 99 } 100 101 return { 102 exports: scriptExports, 103 options: options 104 } 105} 106 107 108/***/ }), 109 110/***/ 1959: 111/***/ (function() { 112 113"use strict";
114// extracted by mini-css-extract-plugin 115 116 117/***/ }), 118 119/***/ 9474: 120/***/ (function() { 121 122"use strict"; 123// extracted by mini-css-extract-plugin 124 125 126/***/ }), 127 128/***/ 8025: 129/***/ (function() { 130 131"use strict"; 132// extracted by mini-css-extract-plugin 133 134 135/***/ }), 136 137/***/ 5201: 138/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 139 140"use strict"; 141 142// EXPORTS 143__webpack_require__.d(__webpack_exports__, { 144 Z: function() { return /* binding */ VAlert; } 145}); 146 147// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 148var web_dom_iterable = __webpack_require__(1181); 149// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 150var defineProperty = __webpack_require__(1180); 151;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VAlert/VAlert.sass 152// extracted by mini-css-extract-plugin 153 154// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/index.js 155var VSheet = __webpack_require__(3555); 156// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VBtn/VBtn.js + 2 modules 157var VBtn = __webpack_require__(1634); 158;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VBtn/index.js 159 160 161/* harmony default export */ var components_VBtn = (VBtn/* default */.Z); 162// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VIcon/index.js 163var VIcon = __webpack_require__(9548); 164// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 165var toggleable = __webpack_require__(1796); 166// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 167var themeable = __webpack_require__(7416); 168// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 169var vue_esm = __webpack_require__(538); 170;// CONCATENATED MODULE: ./node_modules/vuetify/lib/mixins/transitionable/index.js 171 172/* harmony default export */ var transitionable = (vue_esm/* default */.ZP.extend({ 173 name: 'transitionable', 174 props: { 175 mode: String, 176 origin: String, 177 transition: String 178 } 179})); 180// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 181var mixins = __webpack_require__(9547); 182// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 183var console = __webpack_require__(9206); 184;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VAlert/VAlert.js 185 186 187function 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; } 188function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 189// Styles 190 // Extensions 191 192 // Components 193 194 195 // Mixins 196 197 198 199 // Utilities 200 201 202 203/* @vue/component */ 204 205/* harmony default export */ var VAlert = ((0,mixins/* default */.Z)(VSheet/* default */.Z, toggleable/* default */.Z, transitionable).extend({ 206 name: 'v-alert', 207 props: { 208 border: { 209 type: String, 210 validator(val) { 211 return ['top', 'right', 'bottom', 'left'].includes(val); 212 } 213 }, 214 closeLabel: { 215 type: String, 216 default: '$vuetify.close' 217 }, 218 coloredBorder: Boolean, 219 dense: Boolean, 220 dismissible: Boolean, 221 closeIcon: { 222 type: String, 223 default: '$cancel' 224 }, 225 icon: { 226 default: '', 227 type: [Boolean, String], 228 validator(val) { 229 return typeof val === 'string' || val === false; 230 } 231 }, 232 outlined: Boolean, 233 prominent: Boolean, 234 text: Boolean, 235 type: { 236 type: String, 237 validator(val) { 238 return ['info', 'error', 'success', 'warning'].includes(val); 239 } 240 }, 241 value: { 242 type: Boolean, 243 default: true 244 } 245 }, 246 computed: { 247 __cachedBorder() { 248 if (!this.border) return null; 249 let data = { 250 staticClass: 'v-alert__border', 251 class: { 252 [`v-alert__border--${this.border}`]: true 253 } 254 }; 255 if (this.coloredBorder) {
256 data = this.setBackgroundColor(this.computedColor, data); 257 data.class['v-alert__border--has-color'] = true; 258 } 259 return this.$createElement('div', data); 260 }, 261 __cachedDismissible() { 262 if (!this.dismissible) return null; 263 const color = this.iconColor; 264 return this.$createElement(components_VBtn, { 265 staticClass: 'v-alert__dismissible', 266 props: { 267 color, 268 icon: true, 269 small: true 270 }, 271 attrs: { 272 'aria-label': this.$vuetify.lang.t(this.closeLabel) 273 }, 274 on: { 275 click: () => this.isActive = false 276 } 277 }, [this.$createElement(VIcon/* default */.Z, { 278 props: { 279 color 280 } 281 }, this.closeIcon)]); 282 }, 283 __cachedIcon() { 284 if (!this.computedIcon) return null; 285 return this.$createElement(VIcon/* default */.Z, { 286 staticClass: 'v-alert__icon', 287 props: { 288 color: this.iconColor 289 } 290 }, this.computedIcon); 291 }, 292 classes() { 293 const classes = _objectSpread(_objectSpread({}, VSheet/* default */.Z.options.computed.classes.call(this)), {}, { 294 'v-alert--border': Boolean(this.border), 295 'v-alert--dense': this.dense, 296 'v-alert--outlined': this.outlined, 297 'v-alert--prominent': this.prominent, 298 'v-alert--text': this.text 299 }); 300 if (this.border) { 301 classes[`v-alert--border-${this.border}`] = true; 302 } 303 return classes; 304 }, 305 computedColor() { 306 return this.color || this.type; 307 }, 308 computedIcon() { 309 if (this.icon === false) return false; 310 if (typeof this.icon === 'string' && this.icon) return this.icon; 311 if (!['error', 'info', 'success', 'warning'].includes(this.type)) return false; 312 return `$${this.type}`; 313 }, 314 hasColoredIcon() { 315 return this.hasText || Boolean(this.border) && this.coloredBorder; 316 }, 317 hasText() { 318 return this.text || this.outlined; 319 }, 320 iconColor() { 321 return this.hasColoredIcon ? this.computedColor : undefined; 322 }, 323 isDark() { 324 if (this.type && !this.coloredBorder && !this.outlined) return true; 325 return themeable/* default */.Z.options.computed.isDark.call(this); 326 } 327 }, 328 created() { 329 /* istanbul ignore next */ 330 if (this.$attrs.hasOwnProperty('outline')) { 331 (0,console/* breaking */.fK)('outline', 'outlined', this); 332 } 333 }, 334 methods: { 335 genWrapper() { 336 const children = [this.$slots.prepend || this.__cachedIcon, this.genContent(), this.__cachedBorder, this.$slots.append, this.$scopedSlots.close ? this.$scopedSlots.close({ 337 toggle: this.toggle 338 }) : this.__cachedDismissible]; 339 const data = { 340 staticClass: 'v-alert__wrapper' 341 }; 342 return this.$createElement('div', data, children); 343 }, 344 genContent() { 345 return this.$createElement('div', { 346 staticClass: 'v-alert__content' 347 }, this.$slots.default); 348 }, 349 genAlert() { 350 let data = { 351 staticClass: 'v-alert', 352 attrs: { 353 role: 'alert' 354 }, 355 on: this.listeners$, 356 class: this.classes, 357 style: this.styles, 358 directives: [{ 359 name: 'show', 360 value: this.isActive 361 }] 362 }; 363 if (!this.coloredBorder) { 364 const setColor = this.hasText ? this.setTextColor : this.setBackgroundColor; 365 data = setColor(this.computedColor, data); 366 } 367 return this.$createElement('div', data, [this.genWrapper()]); 368 }, 369 /** @public */ 370 toggle() { 371 this.isActive = !this.isActive; 372 } 373 }, 374 render(h) { 375 const render = this.genAlert(); 376 if (!this.transition) return render; 377 return h('transition', { 378 props: { 379 name: this.transition, 380 origin: this.origin, 381 mode: this.mode 382 } 383 }, [render]); 384 } 385})); 386 387/***/ }), 388 389/***/ 3392: 390/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 391 392"use strict"; 393 394// EXPORTS 395__webpack_require__.d(__webpack_exports__, { 396 Z: function() { return /* binding */ VAppBar; } 397}); 398 399// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 400var web_dom_iterable = __webpack_require__(1181); 401// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.fixed.js 402var es6_string_fixed = __webpack_require__(5177); 403// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 404var defineProperty = __webpack_require__(1180); 405;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VAppBar/VAppBar.sass 406// extracted by mini-css-extract-plugin 407 408// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VToolbar/VToolbar.js + 1 modules 409var VToolbar = __webpack_require__(7803); 410;// CONCATENATED MODULE: ./node_modules/vuetify/lib/directives/scroll/index.js 411function inserted(el, binding, vnode) { 412 const _ref = binding.modifiers || {}, 413 _ref$self = _ref.self, 414 self = _ref$self === void 0 ? false : _ref$self; 415 const value = binding.value; 416 const options = typeof value === 'object' && value.options || { 417 passive: true 418 }; 419 const handler = typeof value === 'function' || 'handleEvent' in value ? value : value.handler; 420 const target = self ? el : binding.arg ? document.querySelector(binding.arg) : window; 421 if (!target) return; 422 target.addEventListener('scroll', handler, options); 423 el._onScroll = Object(el._onScroll); 424 el._onScroll[vnode.context._uid] = { 425 handler, 426 options, 427 // Don't reference self 428 target: self ? undefined : target 429 }; 430} 431function unbind(el, binding, vnode) { 432 var _a; 433 if (!((_a = el._onScroll) === null || _a === void 0 ? void 0 : _a[vnode.context._uid])) return; 434 const _el$_onScroll$vnode$c = el._onScroll[vnode.context._uid], 435 handler = _el$_onScroll$vnode$c.handler, 436 options = _el$_onScroll$vnode$c.options, 437 _el$_onScroll$vnode$c2 = _el$_onScroll$vnode$c.target, 438 target = _el$_onScroll$vnode$c2 === void 0 ? el : _el$_onScroll$vnode$c2; 439 target.removeEventListener('scroll', handler, options); 440 delete el._onScroll[vnode.context._uid]; 441} 442const Scroll = { 443 inserted, 444 unbind 445}; 446/* harmony default export */ var directives_scroll = (Scroll); 447// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/applicationable/index.js 448var applicationable = __webpack_require__(4796); 449// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 450var console = __webpack_require__(9206); 451// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 452var vue_esm = __webpack_require__(538); 453;// CONCATENATED MODULE: ./node_modules/vuetify/lib/mixins/scrollable/index.js 454// Directives 455 // Utilities 456 457 // Types 458 459 460/** 461 * Scrollable 462 * 463 * Used for monitoring scrolling and 464 * invoking functions based upon 465 * scrolling thresholds being 466 * met. 467 */ 468 469/* @vue/component */ 470 471/* harmony default export */ var scrollable = (vue_esm/* default */.ZP.extend({ 472 name: 'scrollable', 473 directives: { 474 Scroll: Scroll 475 }, 476 props: { 477 scrollTarget: String, 478 scrollThreshold: [String, Number] 479 }, 480 data: () => ({ 481 currentScroll: 0, 482 currentThreshold: 0, 483 isActive: false, 484 isScrollingUp: false, 485 previousScroll: 0, 486 savedScroll: 0, 487 target: null 488 }), 489 computed: { 490 /** 491 * A computed property that returns 492 * whether scrolling features are 493 * enabled or disabled 494 */ 495 canScroll() { 496 return typeof window !== 'undefined'; 497 }, 498 /** 499 * The threshold that must be met before 500 * thresholdMet function is invoked 501 */ 502 computedScrollThreshold() { 503 return this.scrollThreshold ? Number(this.scrollThreshold) : 300; 504 } 505 }, 506 watch: { 507 isScrollingUp() { 508 this.savedScroll = this.savedScroll || this.currentScroll; 509 }, 510 isActive() { 511 this.savedScroll = 0; 512 } 513 }, 514 mounted() { 515 if (this.scrollTarget) { 516 this.target = document.querySelector(this.scrollTarget); 517 if (!this.target) {
518 (0,console/* consoleWarn */.Kd)(`Unable to locate element with identifier ${this.scrollTarget}`, this); 519 } 520 } 521 }, 522 methods: { 523 onScroll() { 524 if (!this.canScroll) return; 525 this.previousScroll = this.currentScroll; 526 this.currentScroll = this.target ? this.target.scrollTop : window.pageYOffset; 527 this.isScrollingUp = this.currentScroll < this.previousScroll; 528 this.currentThreshold = Math.abs(this.currentScroll - this.computedScrollThreshold); 529 this.$nextTick(() => { 530 if (Math.abs(this.currentScroll - this.savedScroll) > this.computedScrollThreshold) this.thresholdMet(); 531 }); 532 }, 533 /** 534 * The method invoked when 535 * scrolling in any direction 536 * has exceeded the threshold 537 */ 538 thresholdMet() {} 539 } 540})); 541// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/ssr-bootable/index.js 542var ssr_bootable = __webpack_require__(4425); 543// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 544var toggleable = __webpack_require__(1796); 545// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 546var helpers = __webpack_require__(6539); 547// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 548var mixins = __webpack_require__(9547); 549;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VAppBar/VAppBar.js 550 551 552 553function 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; } 554function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 555// Styles 556 // Extensions 557 558 // Directives 559 560 // Mixins 561 562 563 564 565 // Utilities 566 567 568 569const baseMixins = (0,mixins/* default */.Z)(VToolbar/* default */.Z, scrollable, ssr_bootable/* default */.Z, toggleable/* default */.Z, (0,applicationable/* default */.Z)('top', ['clippedLeft', 'clippedRight', 'computedHeight', 'invertedScroll', 'isExtended', 'isProminent', 'value'])); 570/* @vue/component */ 571 572/* harmony default export */ var VAppBar = (baseMixins.extend({ 573 name: 'v-app-bar', 574 directives: { 575 Scroll: directives_scroll 576 }, 577 provide() { 578 return { 579 VAppBar: this 580 }; 581 }, 582 props: { 583 clippedLeft: Boolean, 584 clippedRight: Boolean, 585 collapseOnScroll: Boolean, 586 elevateOnScroll: Boolean, 587 fadeImgOnScroll: Boolean, 588 hideOnScroll: Boolean, 589 invertedScroll: Boolean, 590 scrollOffScreen: Boolean, 591 shrinkOnScroll: Boolean, 592 value: { 593 type: Boolean, 594 default: true 595 } 596 }, 597 data() { 598 return { 599 isActive: this.value 600 }; 601 }, 602 computed: { 603 applicationProperty() { 604 return !this.bottom ? 'top' : 'bottom'; 605 }, 606 canScroll() { 607 return scrollable.options.computed.canScroll.call(this) && (this.invertedScroll || this.elevateOnScroll || this.hideOnScroll || this.collapseOnScroll || this.isBooted || 608 // If falsy, user has provided an 609 // explicit value which should 610 // overwrite anything we do 611 !this.value); 612 }, 613 classes() { 614 return _objectSpread(_objectSpread({}, VToolbar/* default */.Z.options.computed.classes.call(this)), {}, { 615 'v-toolbar--collapse': this.collapse || this.collapseOnScroll, 616 'v-app-bar': true, 617 'v-app-bar--clipped': this.clippedLeft || this.clippedRight, 618 'v-app-bar--fade-img-on-scroll': this.fadeImgOnScroll, 619 'v-app-bar--elevate-on-scroll': this.elevateOnScroll, 620 'v-app-bar--fixed': !this.absolute && (this.app || this.fixed), 621 'v-app-bar--hide-shadow': this.hideShadow, 622 'v-app-bar--is-scrolled': this.currentScroll > 0, 623 'v-app-bar--shrink-on-scroll': this.shrinkOnScroll 624 }); 625 }, 626 scrollRatio() { 627 const threshold = this.computedScrollThreshold; 628 return Math.max((threshold - this.currentScroll) / threshold, 0); 629 }, 630 computedContentHeight() { 631 if (!this.shrinkOnScroll) return VToolbar/* default */.Z.options.computed.computedContentHeight.call(this); 632 const min = this.dense ? 48 : 56; 633 const max = this.computedOriginalHeight; 634 return min + (max - min) * this.scrollRatio; 635 }, 636 computedFontSize() { 637 if (!this.isProminent) return undefined; 638 const min = 1.25; 639 const max = 1.5; 640 return min + (max - min) * this.scrollRatio; 641 }, 642 computedLeft() { 643 if (!this.app || this.clippedLeft) return 0; 644 return this.$vuetify.application.left; 645 }, 646 computedMarginTop() { 647 if (!this.app) return 0; 648 return this.$vuetify.application.bar; 649 }, 650 computedOpacity() { 651 if (!this.fadeImgOnScroll) return undefined; 652 return this.scrollRatio; 653 }, 654 computedOriginalHeight() { 655 let height = VToolbar/* default */.Z.options.computed.computedContentHeight.call(this); 656 if (this.isExtended) height += parseInt(this.extensionHeight); 657 return height; 658 }, 659 computedRight() { 660 if (!this.app || this.clippedRight) return 0; 661 return this.$vuetify.application.right; 662 }, 663 computedScrollThreshold() { 664 if (this.scrollThreshold) return Number(this.scrollThreshold); 665 return this.computedOriginalHeight - (this.dense ? 48 : 56); 666 }, 667 computedTransform() { 668 if (!this.canScroll || this.elevateOnScroll && this.currentScroll === 0 && this.isActive) return 0; 669 if (this.isActive) return 0; 670 const scrollOffScreen = this.scrollOffScreen ? this.computedHeight : this.computedContentHeight; 671 return this.bottom ? scrollOffScreen : -scrollOffScreen; 672 }, 673 hideShadow() { 674 if (this.elevateOnScroll && this.isExtended) { 675 return this.currentScroll < this.computedScrollThreshold; 676 } 677 if (this.elevateOnScroll) { 678 return this.currentScroll === 0 || this.computedTransform < 0; 679 } 680 return (!this.isExtended || this.scrollOffScreen) && this.computedTransform !== 0; 681 }, 682 isCollapsed() { 683 if (!this.collapseOnScroll) { 684 return VToolbar/* default */.Z.options.computed.isCollapsed.call(this); 685 } 686 return this.currentScroll > 0; 687 }, 688 isProminent() { 689 return VToolbar/* default */.Z.options.computed.isProminent.call(this) || this.shrinkOnScroll; 690 }, 691 styles() { 692 return _objectSpread(_objectSpread({}, VToolbar/* default */.Z.options.computed.styles.call(this)), {}, { 693 fontSize: (0,helpers/* convertToUnit */.kb)(this.computedFontSize, 'rem'), 694 marginTop: (0,helpers/* convertToUnit */.kb)(this.computedMarginTop), 695 transform: `translateY(${(0,helpers/* convertToUnit */.kb)(this.computedTransform)})`, 696 left: (0,helpers/* convertToUnit */.kb)(this.computedLeft), 697 right: (0,helpers/* convertToUnit */.kb)(this.computedRight) 698 }); 699 } 700 }, 701 watch: { 702 canScroll: 'onScroll', 703 computedTransform() { 704 // Normally we do not want the v-app-bar 705 // to update the application top value 706 // to avoid screen jump. However, in 707 // this situation, we must so that 708 // the clipped drawer can update 709 // its top value when scrolled 710 if (!this.canScroll || !this.clippedLeft && !this.clippedRight) return; 711 this.callUpdate(); 712 }, 713 invertedScroll(val) { 714 this.isActive = !val || this.currentScroll !== 0; 715 }, 716 hideOnScroll(val) { 717 this.isActive = !val || this.currentScroll < this.computedScrollThreshold; 718 } 719 }, 720 created() { 721 if (this.invertedScroll) this.isActive = false;
722 }, 723 methods: { 724 genBackground() { 725 const render = VToolbar/* default */.Z.options.methods.genBackground.call(this); 726 render.data = this._b(render.data || {}, render.tag, { 727 style: { 728 opacity: this.computedOpacity 729 } 730 }); 731 return render; 732 }, 733 updateApplication() { 734 return this.invertedScroll ? 0 : this.computedHeight + this.computedTransform; 735 }, 736 thresholdMet() { 737 if (this.invertedScroll) { 738 this.isActive = this.currentScroll > this.computedScrollThreshold; 739 return; 740 } 741 if (this.hideOnScroll) { 742 this.isActive = this.isScrollingUp || this.currentScroll < this.computedScrollThreshold; 743 } 744 if (this.currentThreshold < this.computedScrollThreshold) return; 745 this.savedScroll = this.currentScroll; 746 } 747 }, 748 render(h) { 749 const render = VToolbar/* default */.Z.options.render.call(this, h); 750 render.data = render.data || {}; 751 if (this.canScroll) { 752 render.data.directives = render.data.directives || []; 753 render.data.directives.push({ 754 arg: this.scrollTarget, 755 name: 'scroll', 756 value: this.onScroll 757 }); 758 } 759 return render; 760 } 761})); 762 763/***/ }), 764 765/***/ 2204: 766/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 767 768"use strict"; 769 770// EXPORTS 771__webpack_require__.d(__webpack_exports__, { 772 Z: function() { return /* binding */ VApp; } 773}); 774 775// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 776var web_dom_iterable = __webpack_require__(1181); 777// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 778var defineProperty = __webpack_require__(1180); 779;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VApp/VApp.sass 780// extracted by mini-css-extract-plugin 781 782// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 783var themeable = __webpack_require__(7416); 784// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 785var mixins = __webpack_require__(9547); 786;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VApp/VApp.js 787 788 789function 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; } 790function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 791// Styles 792 // Mixins 793 794 // Utilities 795 796 797/* @vue/component */ 798 799/* harmony default export */ var VApp = ((0,mixins/* default */.Z)(themeable/* default */.Z).extend({ 800 name: 'v-app', 801 props: { 802 dark: { 803 type: Boolean, 804 default: undefined 805 }, 806 id: { 807 type: String, 808 default: 'app' 809 }, 810 light: { 811 type: Boolean, 812 default: undefined 813 } 814 }, 815 computed: { 816 isDark() { 817 return this.$vuetify.theme.dark; 818 } 819 }, 820 beforeCreate() { 821 if (!this.$vuetify || this.$vuetify === this.$root) { 822 throw new Error('Vuetify is not properly initialized, see https://v2.vuetifyjs.com/getting-started/quick-start#bootstrapping-the-vuetify-object'); 823 } 824 }, 825 render(h) { 826 const wrapper = h('div', { 827 staticClass: 'v-application--wrap' 828 }, this.$slots.default); 829 return h('div', { 830 staticClass: 'v-application', 831 class: _objectSpread({ 832 'v-application--is-rtl': this.$vuetify.rtl, 833 'v-application--is-ltr': !this.$vuetify.rtl 834 }, this.themeClasses), 835 attrs: { 836 'data-app': true 837 }, 838 domProps: { 839 id: this.id 840 } 841 }, [wrapper]); 842 } 843})); 844 845/***/ }), 846 847/***/ 1634: 848/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 849 850"use strict"; 851 852// EXPORTS 853__webpack_require__.d(__webpack_exports__, { 854 Z: function() { return /* binding */ VBtn; } 855}); 856 857// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 858var web_dom_iterable = __webpack_require__(1181); 859// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 5 modules 860var slicedToArray = __webpack_require__(7625); 861// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.fixed.js 862var es6_string_fixed = __webpack_require__(5177); 863// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 864var defineProperty = __webpack_require__(1180); 865;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VBtn/VBtn.sass 866// extracted by mini-css-extract-plugin 867 868// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/index.js 869var VSheet = __webpack_require__(3555); 870// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VProgressCircular/VProgressCircular.js + 1 modules 871var VProgressCircular = __webpack_require__(8842); 872;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VProgressCircular/index.js 873 874 875/* harmony default export */ var components_VProgressCircular = (VProgressCircular/* default */.Z); 876// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/groupable/index.js 877var groupable = __webpack_require__(1801); 878// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 879var toggleable = __webpack_require__(1796); 880// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/elevatable/index.js 881var elevatable = __webpack_require__(3657); 882// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/positionable/index.js 883var positionable = __webpack_require__(4287); 884// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/routable/index.js 885var routable = __webpack_require__(4520); 886// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/sizeable/index.js 887var sizeable = __webpack_require__(2144); 888// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 889var mixins = __webpack_require__(9547); 890// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 891var console = __webpack_require__(9206); 892;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VBtn/VBtn.js 893 894 895 896 897function 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; } 898function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
898 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 899// Styles 900 // Extensions 901 902 // Components 903 904 // Mixins 905 906 907 908 909 910 911 // Utilities 912 913 914 915const baseMixins = (0,mixins/* default */.Z)(VSheet/* default */.Z, routable/* default */.Z, positionable/* default */.Z, sizeable/* default */.Z, (0,groupable/* factory */.d)('btnToggle'), (0,toggleable/* factory */.d)('inputValue') 916/* @vue/component */); 917/* harmony default export */ var VBtn = (baseMixins.extend().extend({ 918 name: 'v-btn', 919 props: { 920 activeClass: { 921 type: String, 922 default() { 923 if (!this.btnToggle) return ''; 924 return this.btnToggle.activeClass; 925 } 926 }, 927 block: Boolean, 928 depressed: Boolean, 929 fab: Boolean, 930 icon: Boolean, 931 loading: Boolean, 932 outlined: Boolean, 933 plain: Boolean, 934 retainFocusOnClick: Boolean, 935 rounded: Boolean, 936 tag: { 937 type: String, 938 default: 'button' 939 }, 940 text: Boolean, 941 tile: Boolean, 942 type: { 943 type: String, 944 default: 'button' 945 }, 946 value: null 947 }, 948 data: () => ({ 949 proxyClass: 'v-btn--active' 950 }), 951 computed: { 952 classes() { 953 return _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({ 954 'v-btn': true 955 }, routable/* default */.Z.options.computed.classes.call(this)), {}, { 956 'v-btn--absolute': this.absolute, 957 'v-btn--block': this.block, 958 'v-btn--bottom': this.bottom, 959 'v-btn--disabled': this.disabled, 960 'v-btn--is-elevated': this.isElevated, 961 'v-btn--fab': this.fab, 962 'v-btn--fixed': this.fixed, 963 'v-btn--has-bg': this.hasBg, 964 'v-btn--icon': this.icon, 965 'v-btn--left': this.left, 966 'v-btn--loading': this.loading, 967 'v-btn--outlined': this.outlined, 968 'v-btn--plain': this.plain, 969 'v-btn--right': this.right, 970 'v-btn--round': this.isRound, 971 'v-btn--rounded': this.rounded, 972 'v-btn--router': this.to, 973 'v-btn--text': this.text, 974 'v-btn--tile': this.tile, 975 'v-btn--top': this.top 976 }, this.themeClasses), this.groupClasses), this.elevationClasses), this.sizeableClasses); 977 }, 978 computedElevation() { 979 if (this.disabled) return undefined; 980 return elevatable/* default */.Z.options.computed.computedElevation.call(this); 981 }, 982 computedRipple() { 983 var _a; 984 const defaultRipple = this.icon || this.fab ? { 985 circle: true 986 } : true; 987 if (this.disabled) return false;else return (_a = this.ripple) !== null && _a !== void 0 ? _a : defaultRipple; 988 }, 989 hasBg() { 990 return !this.text && !this.plain && !this.outlined && !this.icon; 991 }, 992 isElevated() { 993 return Boolean(!this.icon && !this.text && !this.outlined && !this.depressed && !this.disabled && !this.plain && (this.elevation == null || Number(this.elevation) > 0)); 994 }, 995 isRound() { 996 return Boolean(this.icon || this.fab); 997 }, 998 styles() { 999 return _objectSpread({}, this.measurableStyles); 1000 } 1001 }, 1002 created() { 1003 const breakingProps = [['flat', 'text'], ['outline', 'outlined'], ['round', 'rounded']]; 1004 /* istanbul ignore next */ 1005 1006 breakingProps.forEach(_ref => { 1007 let _ref2 = (0,slicedToArray/* default */.Z)(_ref, 2), 1008 original = _ref2[0], 1009 replacement = _ref2[1]; 1010 if (this.$attrs.hasOwnProperty(original)) (0,console/* breaking */.fK)(original, replacement, this); 1011 }); 1012 }, 1013 methods: { 1014 click(e) { 1015 // TODO: Remove this in v3 1016 !this.retainFocusOnClick && !this.fab && e.detail && this.$el.blur(); 1017 this.$emit('click', e); 1018 this.btnToggle && this.toggle(); 1019 }, 1020 genContent() { 1021 return this.$createElement('span', { 1022 staticClass: 'v-btn__content' 1023 }, this.$slots.default); 1024 }, 1025 genLoader() { 1026 return this.$createElement('span', { 1027 class: 'v-btn__loader' 1028 }, this.$slots.loader || [this.$createElement(components_VProgressCircular, { 1029 props: { 1030 indeterminate: true, 1031 size: 23, 1032 width: 2 1033 } 1034 })]); 1035 } 1036 }, 1037 render(h) { 1038 const children = [this.genContent(), this.loading && this.genLoader()]; 1039 const _this$generateRouteLi = this.generateRouteLink(), 1040 tag = _this$generateRouteLi.tag, 1041 data = _this$generateRouteLi.data;
1042 const setColor = this.hasBg ? this.setBackgroundColor : this.setTextColor; 1043 if (tag === 'button') { 1044 data.attrs.type = this.type; 1045 data.attrs.disabled = this.disabled; 1046 } 1047 data.attrs.value = ['string', 'number'].includes(typeof this.value) ? this.value : JSON.stringify(this.value); 1048 return h(tag, this.disabled ? data : setColor(this.color, data), children); 1049 } 1050})); 1051 1052/***/ }), 1053 1054/***/ 7537: 1055/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 1056 1057"use strict"; 1058 1059// EXPORTS 1060__webpack_require__.d(__webpack_exports__, { 1061 Z: function() { return /* binding */ VCard; } 1062}); 1063 1064// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 1065var web_dom_iterable = __webpack_require__(1181); 1066// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 1067var defineProperty = __webpack_require__(1180); 1068;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VCard/VCard.sass 1069// extracted by mini-css-extract-plugin 1070 1071// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/index.js 1072var VSheet = __webpack_require__(3555); 1073// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/loadable/index.js + 1 modules 1074var loadable = __webpack_require__(5419); 1075// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/routable/index.js 1076var routable = __webpack_require__(4520); 1077// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 1078var mixins = __webpack_require__(9547); 1079;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VCard/VCard.js 1080 1081 1082function 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; } 1083function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 1084// Styles 1085 // Extensions 1086 1087 // Mixins 1088 1089 1090 // Helpers 1091 1092 1093/* @vue/component */ 1094 1095/* harmony default export */ var VCard = ((0,mixins/* default */.Z)(loadable/* default */.Z, routable/* default */.Z, VSheet/* default */.Z).extend({ 1096 name: 'v-card', 1097 props: { 1098 flat: Boolean, 1099 hover: Boolean, 1100 img: String, 1101 link: Boolean, 1102 loaderHeight: { 1103 type: [Number, String], 1104 default: 4 1105 }, 1106 raised: Boolean 1107 }, 1108 computed: { 1109 classes() { 1110 return _objectSpread(_objectSpread({ 1111 'v-card': true 1112 }, routable/* default */.Z.options.computed.classes.call(this)), {}, { 1113 'v-card--flat': this.flat, 1114 'v-card--hover': this.hover, 1115 'v-card--link': this.isClickable, 1116 'v-card--loading': this.loading, 1117 'v-card--disabled': this.disabled, 1118 'v-card--raised': this.raised 1119 }, VSheet/* default */.Z.options.computed.classes.call(this)); 1120 }, 1121 styles() { 1122 const style = _objectSpread({}, VSheet/* default */.Z.options.computed.styles.call(this)); 1123 if (this.img) { 1124 style.background = `url("${this.img}") center center / cover no-repeat`; 1125 } 1126 return style; 1127 } 1128 }, 1129 methods: { 1130 genProgress() { 1131 const render = loadable/* default */.Z.options.methods.genProgress.call(this); 1132 if (!render) return null; 1133 return this.$createElement('div', { 1134 staticClass: 'v-card__progress', 1135 key: 'progress' 1136 }, [render]); 1137 } 1138 }, 1139 render(h) { 1140 const _this$generateRouteLi = this.generateRouteLink(), 1141 tag = _this$generateRouteLi.tag, 1142 data = _this$generateRouteLi.data; 1143 data.style = this.styles; 1144 if (this.isClickable) { 1145 data.attrs = data.attrs || {}; 1146 data.attrs.tabindex = 0; 1147 } 1148 return h(tag, this.setBackgroundColor(this.color, data), [this.genProgress(), this.$slots.default]); 1149 } 1150})); 1151 1152/***/ }), 1153 1154/***/ 5610: 1155/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 1156 1157"use strict"; 1158/* harmony export */ __webpack_require__.d(__webpack_exports__, { 1159/* harmony export */ EB: function() { return /* binding */ VCardTitle; }, 1160/* harmony export */ ZB: function() { return /* binding */ VCardText; }, 1161/* harmony export */ h7: function() { return /* binding */ VCardActions; } 1162/* harmony export */ }); 1163/* unused harmony export VCardSubtitle */ 1164/* harmony import */ var _VCard__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7537); 1165/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6539); 1166 1167 1168const VCardActions = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-card__actions'); 1169const VCardSubtitle = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-card__subtitle'); 1170const VCardText = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-card__text'); 1171const VCardTitle = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-card__title'); 1172 1173/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ({ 1174 $_vuetify_subcomponents: { 1175 VCard: _VCard__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z, 1176 VCardActions, 1177 VCardSubtitle, 1178 VCardText, 1179 VCardTitle 1180 } 1181}); 1182 1183/***/ }), 1184 1185/***/ 1780: 1186/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 1187 1188"use strict"; 1189 1190// EXPORTS 1191__webpack_require__.d(__webpack_exports__, { 1192 Z: function() { return /* binding */ VChip; } 1193}); 1194 1195// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 1196var web_dom_iterable = __webpack_require__(1181); 1197// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 5 modules 1198var slicedToArray = __webpack_require__(7625); 1199// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 1200var defineProperty = __webpack_require__(1180); 1201;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VChip/VChip.sass 1202// extracted by mini-css-extract-plugin 1203 1204// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 1205var mixins = __webpack_require__(9547); 1206// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/transitions/index.js + 2 modules 1207var transitions = __webpack_require__(5712); 1208// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VIcon/index.js 1209var VIcon = __webpack_require__(9548); 1210// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 1211var colorable = __webpack_require__(8390); 1212// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/groupable/index.js 1213var groupable = __webpack_require__(1801); 1214// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 1215var themeable = __webpack_require__(7416); 1216// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 1217var toggleable = __webpack_require__(1796); 1218// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/routable/index.js 1219var routable = __webpack_require__(4520); 1220// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/sizeable/index.js 1221var sizeable = __webpack_require__(2144); 1222// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 1223var console = __webpack_require__(9206); 1224;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VChip/VChip.js 1225 1226 1227 1228function 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; } 1229function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
1229 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 1230// Styles 1231 1232 // Components 1233 1234 1235 // Mixins 1236 1237 1238 1239 1240 1241 1242 // Utilities 1243 1244 1245/* @vue/component */ 1246 1247/* harmony default export */ var VChip = ((0,mixins/* default */.Z)(colorable/* default */.Z, sizeable/* default */.Z, routable/* default */.Z, themeable/* default */.Z, (0,groupable/* factory */.d)('chipGroup'), (0,toggleable/* factory */.d)('inputValue')).extend({ 1248 name: 'v-chip', 1249 props: { 1250 active: { 1251 type: Boolean, 1252 default: true 1253 }, 1254 activeClass: { 1255 type: String, 1256 default() { 1257 if (!this.chipGroup) return ''; 1258 return this.chipGroup.activeClass; 1259 } 1260 }, 1261 close: Boolean, 1262 closeIcon: { 1263 type: String, 1264 default: '$delete' 1265 }, 1266 closeLabel: { 1267 type: String, 1268 default: '$vuetify.close' 1269 }, 1270 disabled: Boolean, 1271 draggable: Boolean, 1272 filter: Boolean, 1273 filterIcon: { 1274 type: String, 1275 default: '$complete' 1276 }, 1277 label: Boolean, 1278 link: Boolean, 1279 outlined: Boolean, 1280 pill: Boolean, 1281 tag: { 1282 type: String, 1283 default: 'span' 1284 }, 1285 textColor: String, 1286 value: null 1287 }, 1288 data: () => ({ 1289 proxyClass: 'v-chip--active' 1290 }), 1291 computed: { 1292 classes() { 1293 return _objectSpread(_objectSpread(_objectSpread(_objectSpread({ 1294 'v-chip': true 1295 }, routable/* default */.Z.options.computed.classes.call(this)), {}, { 1296 'v-chip--clickable': this.isClickable, 1297 'v-chip--disabled': this.disabled, 1298 'v-chip--draggable': this.draggable, 1299 'v-chip--label': this.label, 1300 'v-chip--link': this.isLink, 1301 'v-chip--no-color': !this.color, 1302 'v-chip--outlined': this.outlined, 1303 'v-chip--pill': this.pill, 1304 'v-chip--removable': this.hasClose 1305 }, this.themeClasses), this.sizeableClasses), this.groupClasses); 1306 }, 1307 hasClose() { 1308 return Boolean(this.close); 1309 }, 1310 isClickable() { 1311 return Boolean(routable/* default */.Z.options.computed.isClickable.call(this) || this.chipGroup); 1312 } 1313 }, 1314 created() { 1315 const breakingProps = [['outline', 'outlined'], ['selected', 'input-value'], ['value', 'active'], ['@input', '@active.sync']]; 1316 /* istanbul ignore next */ 1317 1318 breakingProps.forEach(_ref => { 1319 let _ref2 = (0,slicedToArray/* default */.Z)(_ref, 2), 1320 original = _ref2[0], 1321 replacement = _ref2[1]; 1322 if (this.$attrs.hasOwnProperty(original)) (0,console/* breaking */.fK)(original, replacement, this); 1323 }); 1324 }, 1325 methods: { 1326 click(e) { 1327 this.$emit('click', e); 1328 this.chipGroup && this.toggle(); 1329 }, 1330 genFilter() { 1331 const children = []; 1332 if (this.isActive) { 1333 children.push(this.$createElement(VIcon/* default */.Z, { 1334 staticClass: 'v-chip__filter', 1335 props: { 1336 left: true 1337 } 1338 }, this.filterIcon)); 1339 } 1340 return this.$createElement(transitions/* VExpandXTransition */.Zq, children); 1341 }, 1342 genClose() { 1343 return this.$createElement(VIcon/* default */.Z, { 1344 staticClass: 'v-chip__close', 1345 props: { 1346 right: true, 1347 size: 18 1348 }, 1349 attrs: { 1350 'aria-label': this.$vuetify.lang.t(this.closeLabel) 1351 }, 1352 on: { 1353 click: e => { 1354 e.stopPropagation(); 1355 e.preventDefault(); 1356 this.$emit('click:close'); 1357 this.$emit('update:active', false); 1358 } 1359 } 1360 }, this.closeIcon); 1361 }, 1362 genContent() { 1363 return this.$createElement('span', { 1364 staticClass: 'v-chip__content' 1365 }, [this.filter && this.genFilter(), this.$slots.default, this.hasClose && this.genClose()]); 1366 } 1367 }, 1368 render(h) { 1369 const children = [this.genContent()]; 1370 let _this$generateRouteLi = this.generateRouteLink(), 1371 tag = _this$generateRouteLi.tag, 1372 data = _this$generateRouteLi.data; 1373 data.attrs = _objectSpread(_objectSpread({}, data.attrs), {}, { 1374 draggable: this.draggable ? 'true' : undefined, 1375 tabindex: this.chipGroup && !this.disabled ? 0 : data.attrs.tabindex 1376 }); 1377 data.directives.push({ 1378 name: 'show', 1379 value: this.active 1380 });
1381 data = this.setBackgroundColor(this.color, data); 1382 const color = this.textColor || this.outlined && this.color; 1383 return h(tag, this.setTextColor(color, data), children); 1384 } 1385})); 1386 1387/***/ }), 1388 1389/***/ 1367: 1390/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 1391 1392"use strict"; 1393 1394// EXPORTS 1395__webpack_require__.d(__webpack_exports__, { 1396 Z: function() { return /* binding */ VDialog; } 1397}); 1398 1399// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 1400var web_dom_iterable = __webpack_require__(1181); 1401// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 1402var defineProperty = __webpack_require__(1180); 1403;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VDialog/VDialog.sass 1404// extracted by mini-css-extract-plugin 1405 1406// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VThemeProvider/VThemeProvider.js 1407var VThemeProvider = __webpack_require__(7981); 1408// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/activatable/index.js 1409var activatable = __webpack_require__(2994); 1410// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/dependent/index.js 1411var dependent = __webpack_require__(1511); 1412// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/detachable/index.js 1413var detachable = __webpack_require__(9865); 1414;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VOverlay/VOverlay.sass 1415// extracted by mini-css-extract-plugin 1416 1417// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 1418var colorable = __webpack_require__(8390); 1419// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 1420var themeable = __webpack_require__(7416); 1421// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 1422var toggleable = __webpack_require__(1796); 1423// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 1424var mixins = __webpack_require__(9547); 1425;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VOverlay/VOverlay.js 1426 1427 1428function 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; } 1429function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 1430// Styles 1431 // Mixins 1432 1433 1434 1435 // Utilities 1436 1437 1438/* @vue/component */ 1439 1440/* harmony default export */ var VOverlay = ((0,mixins/* default */.Z)(colorable/* default */.Z, themeable/* default */.Z, toggleable/* default */.Z).extend({ 1441 name: 'v-overlay', 1442 props: { 1443 absolute: Boolean, 1444 color: { 1445 type: String, 1446 default: '#212121' 1447 }, 1448 dark: { 1449 type: Boolean, 1450 default: true 1451 }, 1452 opacity: { 1453 type: [Number, String], 1454 default: 0.46 1455 }, 1456 value: { 1457 default: true 1458 }, 1459 zIndex: { 1460 type: [Number, String], 1461 default: 5 1462 } 1463 }, 1464 computed: { 1465 __scrim() { 1466 const data = this.setBackgroundColor(this.color, { 1467 staticClass: 'v-overlay__scrim', 1468 style: { 1469 opacity: this.computedOpacity 1470 } 1471 }); 1472 return this.$createElement('div', data); 1473 }, 1474 classes() { 1475 return _objectSpread({ 1476 'v-overlay--absolute': this.absolute, 1477 'v-overlay--active': this.isActive 1478 }, this.themeClasses); 1479 }, 1480 computedOpacity() { 1481 return Number(this.isActive ? this.opacity : 0); 1482 }, 1483 styles() { 1484 return { 1485 zIndex: this.zIndex 1486 }; 1487 } 1488 }, 1489 methods: { 1490 genContent() { 1491 return this.$createElement('div', { 1492 staticClass: 'v-overlay__content' 1493 }, this.$slots.default); 1494 } 1495 }, 1496 render(h) { 1497 const children = [this.__scrim]; 1498 if (this.isActive) children.push(this.genContent()); 1499 return h('div', { 1500 staticClass: 'v-overlay', 1501 on: this.$listeners, 1502 class: this.classes, 1503 style: this.styles 1504 }, children); 1505 } 1506})); 1507;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VOverlay/index.js 1508 1509 1510/* harmony default export */ var components_VOverlay = (VOverlay); 1511// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 1512var helpers = __webpack_require__(6539); 1513// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 1514var vue_esm = __webpack_require__(538); 1515;// CONCATENATED MODULE: ./node_modules/vuetify/lib/mixins/overlayable/index.js 1516// Components 1517 // Utilities 1518 1519 // Types 1520 1521 1522/* @vue/component */ 1523 1524/* harmony default export */ var overlayable = (vue_esm/* default */.ZP.extend().extend({ 1525 name: 'overlayable', 1526 props: { 1527 hideOverlay: Boolean, 1528 overlayColor: String, 1529 overlayOpacity: [Number, String] 1530 }, 1531 data() { 1532 return { 1533 animationFrame: 0, 1534 overlay: null 1535 }; 1536 }, 1537 watch: { 1538 hideOverlay(value) { 1539 if (!this.isActive) return; 1540 if (value) this.removeOverlay();else this.genOverlay(); 1541 } 1542 }, 1543 beforeDestroy() { 1544 this.removeOverlay(); 1545 }, 1546 methods: { 1547 createOverlay() {
1548 const overlay = new components_VOverlay({ 1549 propsData: { 1550 absolute: this.absolute, 1551 value: false, 1552 color: this.overlayColor, 1553 opacity: this.overlayOpacity 1554 } 1555 }); 1556 overlay.$mount(); 1557 const parent = this.absolute ? this.$el.parentNode : document.querySelector('[data-app]'); 1558 parent && parent.insertBefore(overlay.$el, parent.firstChild); 1559 this.overlay = overlay; 1560 }, 1561 genOverlay() { 1562 this.hideScroll(); 1563 if (this.hideOverlay) return; 1564 if (!this.overlay) this.createOverlay(); 1565 this.animationFrame = requestAnimationFrame(() => { 1566 if (!this.overlay) return; 1567 if (this.activeZIndex !== undefined) { 1568 this.overlay.zIndex = String(this.activeZIndex - 1); 1569 } else if (this.$el) { 1570 this.overlay.zIndex = (0,helpers/* getZIndex */.KK)(this.$el); 1571 } 1572 this.overlay.value = true; 1573 }); 1574 return true; 1575 }, 1576 /** removeOverlay(false) will not restore the scollbar afterwards */ 1577 removeOverlay() { 1578 let showScroll = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; 1579 if (this.overlay) { 1580 (0,helpers/* addOnceEventListener */.qh)(this.overlay.$el, 'transitionend', () => { 1581 if (!this.overlay || !this.overlay.$el || !this.overlay.$el.parentNode || this.overlay.value || this.isActive) return; 1582 this.overlay.$el.parentNode.removeChild(this.overlay.$el); 1583 this.overlay.$destroy(); 1584 this.overlay = null; 1585 }); // Cancel animation frame in case 1586 // overlay is removed before it 1587 // has finished its animation 1588 1589 cancelAnimationFrame(this.animationFrame); 1590 this.overlay.value = false; 1591 } 1592 showScroll && this.showScroll(); 1593 }, 1594 scrollListener(e) { 1595 if ('key' in e) { 1596 if (['INPUT', 'TEXTAREA', 'SELECT'].includes(e.target.tagName) || 1597 // https://github.com/vuetifyjs/vuetify/issues/4715 1598 e.target.isContentEditable) return; 1599 const up = [helpers/* keyCodes */.Do.up, helpers/* keyCodes */.Do.pageup]; 1600 const down = [helpers/* keyCodes */.Do.down, helpers/* keyCodes */.Do.pagedown]; 1601 if (up.includes(e.keyCode)) { 1602 e.deltaY = -1; 1603 } else if (down.includes(e.keyCode)) { 1604 e.deltaY = 1; 1605 } else { 1606 return; 1607 } 1608 } 1609 if (e.target === this.overlay || e.type !== 'keydown' && e.target === document.body || this.checkPath(e)) e.preventDefault(); 1610 }, 1611 hasScrollbar(el) { 1612 if (!el || el.nodeType !== Node.ELEMENT_NODE) return false; 1613 const style = window.getComputedStyle(el); 1614 return (['auto', 'scroll'].includes(style.overflowY) || el.tagName === 'SELECT') && el.scrollHeight > el.clientHeight || ['auto', 'scroll'].includes(style.overflowX) && el.scrollWidth > el.clientWidth; 1615 }, 1616 shouldScroll(el, e) { 1617 if (el.hasAttribute('data-app')) return false; 1618 const dir = e.shiftKey || e.deltaX ? 'x' : 'y'; 1619 const delta = dir === 'y' ? e.deltaY : e.deltaX || e.deltaY; 1620 let alreadyAtStart; 1621 let alreadyAtEnd; 1622 if (dir === 'y') { 1623 alreadyAtStart = el.scrollTop === 0; 1624 alreadyAtEnd = el.scrollTop + el.clientHeight === el.scrollHeight; 1625 } else { 1626 alreadyAtStart = el.scrollLeft === 0; 1627 alreadyAtEnd = el.scrollLeft + el.clientWidth === el.scrollWidth; 1628 } 1629 const scrollingUp = delta < 0; 1630 const scrollingDown = delta > 0; 1631 if (!alreadyAtStart && scrollingUp) return true; 1632 if (!alreadyAtEnd && scrollingDown) return true; 1633 if ((alreadyAtStart || alreadyAtEnd) && el.parentNode) { 1634 return this.shouldScroll(el.parentNode, e); 1635 } 1636 return false; 1637 }, 1638 isInside(el, parent) { 1639 if (el === parent) { 1640 return true; 1641 } else if (el === null || el === document.body) { 1642 return false; 1643 } else { 1644 return this.isInside(el.parentNode, parent); 1645 } 1646 }, 1647 checkPath(e) { 1648 const path = (0,helpers/* composedPath */.iZ)(e); 1649 if (e.type === 'keydown' && path[0] === document.body) { 1650 const dialog = this.$refs.dialog; // getSelection returns null in firefox in some edge cases, can be ignored 1651 1652 const selected = window.getSelection().anchorNode; 1653 if (dialog && this.hasScrollbar(dialog) && this.isInside(selected, dialog)) { 1654 return !this.shouldScroll(dialog, e); 1655 } 1656 return true; 1657 } 1658 for (let index = 0; index < path.length; index++) { 1659 const el = path[index]; 1660 if (el === document) return true; 1661 if (el === document.documentElement) return true; 1662 if (el === this.$refs.content) return true; 1663 if (this.hasScrollbar(el)) return !this.shouldScroll(el, e); 1664 } 1665 return true; 1666 }, 1667 hideScroll() { 1668 if (this.$vuetify.breakpoint.smAndDown) { 1669 document.documentElement.classList.add('overflow-y-hidden'); 1670 } else { 1671 (0,helpers/* addPassiveEventListener */.lj)(window, 'wheel', this.scrollListener, { 1672 passive: false 1673 }); 1674 window.addEventListener('keydown', this.scrollListener); 1675 } 1676 }, 1677 showScroll() { 1678 document.documentElement.classList.remove('overflow-y-hidden'); 1679 window.removeEventListener('wheel', this.scrollListener); 1680 window.removeEventListener('keydown', this.scrollListener); 1681 } 1682 } 1683})); 1684// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/returnable/index.js 1685var returnable = __webpack_require__(6949); 1686// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/stackable/index.js 1687var stackable = __webpack_require__(6250); 1688// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/click-outside/index.js 1689var click_outside = __webpack_require__(6974); 1690// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 1691var console = __webpack_require__(9206); 1692;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VDialog/VDialog.js 1693 1694 1695function VDialog_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; } 1696function VDialog_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
1696 r % 2 ? VDialog_ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : VDialog_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 1697// Styles 1698 // Components 1699 1700 // Mixins 1701 1702 1703 1704 1705 1706 1707 // Directives 1708 1709 // Helpers 1710 1711 1712 1713 1714const baseMixins = (0,mixins/* default */.Z)(dependent/* default */.Z, detachable/* default */.Z, overlayable, returnable/* default */.Z, stackable/* default */.Z, activatable/* default */.Z); 1715/* @vue/component */ 1716 1717/* harmony default export */ var VDialog = (baseMixins.extend({ 1718 name: 'v-dialog', 1719 directives: { 1720 ClickOutside: click_outside/* default */.Z 1721 }, 1722 props: { 1723 dark: Boolean, 1724 disabled: Boolean, 1725 fullscreen: Boolean, 1726 light: Boolean, 1727 maxWidth: [String, Number], 1728 noClickAnimation: Boolean, 1729 origin: { 1730 type: String, 1731 default: 'center center' 1732 }, 1733 persistent: Boolean, 1734 retainFocus: { 1735 type: Boolean, 1736 default: true 1737 }, 1738 scrollable: Boolean, 1739 transition: { 1740 type: [String, Boolean], 1741 default: 'dialog-transition' 1742 }, 1743 width: [String, Number] 1744 }, 1745 data() { 1746 return { 1747 activatedBy: null, 1748 animate: false, 1749 animateTimeout: -1, 1750 stackMinZIndex: 200, 1751 previousActiveElement: null 1752 }; 1753 }, 1754 computed: { 1755 classes() { 1756 return { 1757 [`v-dialog ${this.contentClass}`.trim()]: true, 1758 'v-dialog--active': this.isActive, 1759 'v-dialog--persistent': this.persistent, 1760 'v-dialog--fullscreen': this.fullscreen, 1761 'v-dialog--scrollable': this.scrollable, 1762 'v-dialog--animated': this.animate 1763 }; 1764 }, 1765 contentClasses() { 1766 return { 1767 'v-dialog__content': true, 1768 'v-dialog__content--active': this.isActive 1769 }; 1770 }, 1771 hasActivator() { 1772 return Boolean(!!this.$slots.activator || !!this.$scopedSlots.activator); 1773 } 1774 }, 1775 watch: { 1776 isActive(val) { 1777 var _a; 1778 if (val) { 1779 this.show(); 1780 this.hideScroll(); 1781 } else { 1782 this.removeOverlay(); 1783 this.unbind(); 1784 (_a = this.previousActiveElement) === null || _a === void 0 ? void 0 : _a.focus(); 1785 } 1786 }, 1787 fullscreen(val) { 1788 if (!this.isActive) return; 1789 if (val) { 1790 this.hideScroll(); 1791 this.removeOverlay(false); 1792 } else { 1793 this.showScroll(); 1794 this.genOverlay(); 1795 } 1796 } 1797 }, 1798 created() { 1799 /* istanbul ignore next */ 1800 if (this.$attrs.hasOwnProperty('full-width')) { 1801 (0,console/* removed */.Jk)('full-width', this); 1802 } 1803 }, 1804 beforeMount() { 1805 this.$nextTick(() => { 1806 this.isBooted = this.isActive; 1807 this.isActive && this.show(); 1808 }); 1809 }, 1810 beforeDestroy() { 1811 if (typeof window !== 'undefined') this.unbind(); 1812 }, 1813 methods: { 1814 animateClick() { 1815 this.animate = false; // Needed for when clicking very fast 1816 // outside of the dialog 1817 1818 this.$nextTick(() => { 1819 this.animate = true; 1820 window.clearTimeout(this.animateTimeout); 1821 this.animateTimeout = window.setTimeout(() => this.animate = false, 150); 1822 }); 1823 }, 1824 closeConditional(e) { 1825 const target = e.target; // Ignore the click if the dialog is closed or destroyed, 1826 // if it was on an element inside the content, 1827 // if it was dragged onto the overlay (#6969), 1828 // or if this isn't the topmost dialog (#9907) 1829 1830 return !(this._isDestroyed || !this.isActive || this.$refs.content.contains(target) || this.overlay && target && !this.overlay.$el.contains(target)) && this.activeZIndex >= this.getMaxZIndex(); 1831 }, 1832 hideScroll() { 1833 if (this.fullscreen) { 1834 document.documentElement.classList.add('overflow-y-hidden'); 1835 } else { 1836 overlayable.options.methods.hideScroll.call(this); 1837 } 1838 }, 1839 show() { 1840 !this.fullscreen && !this.hideOverlay && this.genOverlay(); // Double nextTick to wait for lazy content to be generated 1841 1842 this.$nextTick(() => { 1843 this.$nextTick(() => { 1844 var _a, _b; 1845 if (!((_a = this.$refs.dialog) === null || _a === void 0 ? void 0 : _a.contains(document.activeElement))) { 1846 this.previousActiveElement = document.activeElement; 1847 (_b = this.$refs.dialog) === null || _b === void 0 ? void 0 : _b.focus(); 1848 } 1849 this.bind(); 1850 }); 1851 }); 1852 }, 1853 bind() { 1854 window.addEventListener('focusin', this.onFocusin); 1855 }, 1856 unbind() { 1857 window.removeEventListener('focusin', this.onFocusin); 1858 }, 1859 onClickOutside(e) { 1860 this.$emit('click:outside', e); 1861 if (this.persistent) { 1862 this.noClickAnimation || this.animateClick(); 1863 } else { 1864 this.isActive = false;
1865 } 1866 }, 1867 onKeydown(e) { 1868 if (e.keyCode === helpers/* keyCodes */.Do.esc && !this.getOpenDependents().length) { 1869 if (!this.persistent) { 1870 this.isActive = false; 1871 const activator = this.getActivator(); 1872 this.$nextTick(() => activator && activator.focus()); 1873 } else if (!this.noClickAnimation) { 1874 this.animateClick(); 1875 } 1876 } 1877 this.$emit('keydown', e); 1878 }, 1879 // On focus change, wrap focus to stay inside the dialog 1880 // https://github.com/vuetifyjs/vuetify/issues/6892 1881 onFocusin(e) { 1882 if (!e || !this.retainFocus) return; 1883 const target = e.target; 1884 if (!!target && this.$refs.dialog && 1885 // It isn't the document or the dialog body 1886 ![document, this.$refs.dialog].includes(target) && 1887 // It isn't inside the dialog body 1888 !this.$refs.dialog.contains(target) && 1889 // We're the topmost dialog 1890 this.activeZIndex >= this.getMaxZIndex() && 1891 // It isn't inside a dependent element (like a menu) 1892 !this.getOpenDependentElements().some(el => el.contains(target)) // So we must have focused something outside the dialog and its children 1893 ) { 1894 // Find and focus the first available element inside the dialog 1895 const focusable = this.$refs.dialog.querySelectorAll('button, [href], input:not([type="hidden"]), select, textarea, [tabindex]:not([tabindex="-1"])'); 1896 const el = [...focusable].find(el => !el.hasAttribute('disabled') && !el.matches('[tabindex="-1"]')); 1897 el && el.focus(); 1898 } 1899 }, 1900 genContent() { 1901 return this.showLazyContent(() => [this.$createElement(VThemeProvider/* default */.Z, { 1902 props: { 1903 root: true, 1904 light: this.light, 1905 dark: this.dark 1906 } 1907 }, [this.$createElement('div', { 1908 class: this.contentClasses, 1909 attrs: VDialog_objectSpread({ 1910 role: 'dialog',
1911 'aria-modal': this.hideOverlay ? undefined : 'true' 1912 }, this.getScopeIdAttrs()), 1913 on: { 1914 keydown: this.onKeydown 1915 }, 1916 style: { 1917 zIndex: this.activeZIndex 1918 }, 1919 ref: 'content' 1920 }, [this.genTransition()])])]); 1921 }, 1922 genTransition() { 1923 const content = this.genInnerContent(); 1924 if (!this.transition) return content; 1925 return this.$createElement('transition', { 1926 props: { 1927 name: this.transition, 1928 origin: this.origin, 1929 appear: true 1930 } 1931 }, [content]); 1932 }, 1933 genInnerContent() { 1934 const data = { 1935 class: this.classes, 1936 attrs: { 1937 tabindex: this.isActive ? 0 : undefined 1938 }, 1939 ref: 'dialog', 1940 directives: [{ 1941 name: 'click-outside', 1942 value: { 1943 handler: this.onClickOutside, 1944 closeConditional: this.closeConditional, 1945 include: this.getOpenDependentElements 1946 } 1947 }, { 1948 name: 'show', 1949 value: this.isActive 1950 }], 1951 style: { 1952 transformOrigin: this.origin 1953 } 1954 }; 1955 if (!this.fullscreen) { 1956 data.style = VDialog_objectSpread(VDialog_objectSpread({}, data.style), {}, { 1957 maxWidth: (0,helpers/* convertToUnit */.kb)(this.maxWidth), 1958 width: (0,helpers/* convertToUnit */.kb)(this.width) 1959 }); 1960 } 1961 return this.$createElement('div', data, this.getContentSlot()); 1962 } 1963 }, 1964 render(h) { 1965 return h('div', { 1966 staticClass: 'v-dialog__container', 1967 class: { 1968 'v-dialog__container--attached': this.attach === '' || this.attach === true || this.attach === 'attach' 1969 } 1970 }, [this.genActivator(), this.genContent()]); 1971 } 1972})); 1973 1974/***/ }), 1975 1976/***/ 3190: 1977/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 1978 1979"use strict"; 1980 1981// EXPORTS 1982__webpack_require__.d(__webpack_exports__, { 1983 Z: function() { return /* binding */ VDivider; } 1984}); 1985 1986// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 1987var web_dom_iterable = __webpack_require__(1181); 1988// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 1989var defineProperty = __webpack_require__(1180); 1990;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VDivider/VDivider.sass 1991// extracted by mini-css-extract-plugin 1992 1993// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 1994var themeable = __webpack_require__(7416); 1995;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VDivider/VDivider.js 1996 1997 1998function 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; } 1999function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 2000// Styles 2001 // Mixins 2002 2003 2004/* harmony default export */ var VDivider = (themeable/* default */.Z.extend({ 2005 name: 'v-divider', 2006 props: { 2007 inset: Boolean, 2008 vertical: Boolean 2009 }, 2010 render(h) { 2011 // WAI-ARIA attributes 2012 let orientation; 2013 if (!this.$attrs.role || this.$attrs.role === 'separator') { 2014 orientation = this.vertical ? 'vertical' : 'horizontal'; 2015 } 2016 return h('hr', { 2017 class: _objectSpread({ 2018 'v-divider': true, 2019 'v-divider--inset': this.inset, 2020 'v-divider--vertical': this.vertical 2021 }, this.themeClasses), 2022 attrs: _objectSpread({ 2023 role: 'separator', 2024 'aria-orientation': orientation 2025 }, this.$attrs), 2026 on: this.$listeners 2027 }); 2028 } 2029})); 2030 2031/***/ }), 2032 2033/***/ 6279: 2034/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2035 2036"use strict"; 2037 2038// EXPORTS 2039__webpack_require__.d(__webpack_exports__, { 2040 Z: function() { return /* binding */ VFooter; } 2041}); 2042 2043// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 2044var web_dom_iterable = __webpack_require__(1181); 2045// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.fixed.js 2046var es6_string_fixed = __webpack_require__(5177); 2047// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 2048var defineProperty = __webpack_require__(1180); 2049;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VFooter/VFooter.sass 2050// extracted by mini-css-extract-plugin 2051 2052// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/VSheet.js + 1 modules 2053var VSheet = __webpack_require__(1685); 2054// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/applicationable/index.js 2055var applicationable = __webpack_require__(4796); 2056// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/ssr-bootable/index.js 2057var ssr_bootable = __webpack_require__(4425); 2058// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 2059var mixins = __webpack_require__(9547); 2060// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 2061var helpers = __webpack_require__(6539); 2062;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VFooter/VFooter.js 2063 2064 2065 2066function 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; } 2067function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
2067 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 2068// Styles 2069 // Components 2070 2071 // Mixins 2072 2073 2074 // Utilities 2075 2076 2077 2078/* @vue/component */ 2079 2080/* harmony default export */ var VFooter = ((0,mixins/* default */.Z)(VSheet/* default */.Z, (0,applicationable/* default */.Z)('footer', ['height', 'inset']), ssr_bootable/* default */.Z).extend({ 2081 name: 'v-footer', 2082 props: { 2083 height: { 2084 default: 'auto', 2085 type: [Number, String] 2086 }, 2087 inset: Boolean, 2088 padless: Boolean, 2089 tag: { 2090 type: String, 2091 default: 'footer' 2092 } 2093 }, 2094 computed: { 2095 applicationProperty() { 2096 return this.inset ? 'insetFooter' : 'footer'; 2097 }, 2098 classes() { 2099 return _objectSpread(_objectSpread({}, VSheet/* default */.Z.options.computed.classes.call(this)), {}, { 2100 'v-footer--absolute': this.absolute, 2101 'v-footer--fixed': !this.absolute && (this.app || this.fixed), 2102 'v-footer--padless': this.padless, 2103 'v-footer--inset': this.inset 2104 }); 2105 }, 2106 computedBottom() { 2107 if (!this.isPositioned) return undefined; 2108 return this.app ? this.$vuetify.application.bottom : 0; 2109 }, 2110 computedLeft() { 2111 if (!this.isPositioned) return undefined; 2112 return this.app && this.inset ? this.$vuetify.application.left : 0; 2113 }, 2114 computedRight() { 2115 if (!this.isPositioned) return undefined; 2116 return this.app && this.inset ? this.$vuetify.application.right : 0; 2117 }, 2118 isPositioned() { 2119 return Boolean(this.absolute || this.fixed || this.app); 2120 }, 2121 styles() { 2122 const height = parseInt(this.height); 2123 return _objectSpread(_objectSpread({}, VSheet/* default */.Z.options.computed.styles.call(this)), {}, { 2124 height: isNaN(height) ? height : (0,helpers/* convertToUnit */.kb)(height), 2125 left: (0,helpers/* convertToUnit */.kb)(this.computedLeft), 2126 right: (0,helpers/* convertToUnit */.kb)(this.computedRight), 2127 bottom: (0,helpers/* convertToUnit */.kb)(this.computedBottom) 2128 }); 2129 } 2130 }, 2131 methods: { 2132 updateApplication() { 2133 const height = parseInt(this.height); 2134 return isNaN(height) ? this.$el ? this.$el.clientHeight : 0 : height; 2135 } 2136 }, 2137 render(h) { 2138 const data = this.setBackgroundColor(this.color, { 2139 staticClass: 'v-footer', 2140 class: this.classes, 2141 style: this.styles 2142 }); 2143 return h(this.tag, data, this.$slots.default); 2144 } 2145})); 2146 2147/***/ }), 2148 2149/***/ 4544: 2150/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2151 2152"use strict"; 2153/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1180); 2154/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9357); 2155/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0__); 2156/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1181); 2157/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1__); 2158/* harmony import */ var _src_components_VGrid_VGrid_sass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1959); 2159/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(538); 2160/* harmony import */ var _util_mergeData__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(8097); 2161/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 2162 2163 2164 2165function 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; } 2166function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
2166 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(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; } 2167 2168 2169 2170 // no xs 2171 2172const breakpoints = ['sm', 'md', 'lg', 'xl']; 2173const breakpointProps = (() => { 2174 return breakpoints.reduce((props, val) => { 2175 props[val] = { 2176 type: [Boolean, String, Number], 2177 default: false 2178 }; 2179 return props; 2180 }, {}); 2181})(); 2182const offsetProps = (() => { 2183 return breakpoints.reduce((props, val) => { 2184 props['offset' + (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .upperFirst */ .jC)(val)] = { 2185 type: [String, Number], 2186 default: null 2187 }; 2188 return props; 2189 }, {}); 2190})(); 2191const orderProps = (() => { 2192 return breakpoints.reduce((props, val) => { 2193 props['order' + (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .upperFirst */ .jC)(val)] = { 2194 type: [String, Number], 2195 default: null 2196 }; 2197 return props; 2198 }, {}); 2199})(); 2200const propMap = { 2201 col: Object.keys(breakpointProps), 2202 offset: Object.keys(offsetProps), 2203 order: Object.keys(orderProps) 2204}; 2205function breakpointClass(type, prop, val) { 2206 let className = type; 2207 if (val == null || val === false) { 2208 return undefined; 2209 } 2210 if (prop) { 2211 const breakpoint = prop.replace(type, ''); 2212 className += `-${breakpoint}`; 2213 } // Handling the boolean style prop when accepting [Boolean, String, Number] 2214 // means Vue will not convert <v-col sm></v-col> to sm: true for us. 2215 // Since the default is false, an empty string indicates the prop's presence. 2216 2217 if (type === 'col' && (val === '' || val === true)) { 2218 // .col-md 2219 return className.toLowerCase(); 2220 } // .order-md-6 2221 2222 className += `-${val}`; 2223 return className.toLowerCase(); 2224} 2225const cache = new Map(); 2226/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .ZP.extend({ 2227 name: 'v-col', 2228 functional: true, 2229 props: _objectSpread(_objectSpread(_objectSpread(_objectSpread({ 2230 cols: { 2231 type: [Boolean, String, Number], 2232 default: false 2233 } 2234 }, breakpointProps), {}, { 2235 offset: { 2236 type: [String, Number], 2237 default: null 2238 } 2239 }, offsetProps), {}, { 2240 order: { 2241 type: [String, Number], 2242 default: null 2243 } 2244 }, orderProps), {}, { 2245 alignSelf: { 2246 type: String, 2247 default: null, 2248 validator: str => ['auto', 'start', 'end', 'center', 'baseline', 'stretch'].includes(str) 2249 }, 2250 tag: { 2251 type: String, 2252 default: 'div' 2253 } 2254 }), 2255 render(h, _ref) { 2256 let props = _ref.props, 2257 data = _ref.data, 2258 children = _ref.children, 2259 parent = _ref.parent; 2260 // Super-fast memoization based on props, 5x faster than JSON.stringify 2261 let cacheKey = ''; 2262 for (const prop in props) { 2263 cacheKey += String(props[prop]); 2264 } 2265 let classList = cache.get(cacheKey); 2266 if (!classList) { 2267 classList = []; // Loop through `col`, `offset`, `order` breakpoint props 2268 2269 let type; 2270 for (type in propMap) { 2271 propMap[type].forEach(prop => { 2272 const value = props[prop]; 2273 const className = breakpointClass(type, prop, value); 2274 if (className) classList.push(className); 2275 }); 2276 } 2277 const hasColClasses = classList.some(className => className.startsWith('col-')); 2278 classList.push({ 2279 // Default to .col if no other col-{bp}-* classes generated nor `cols` specified. 2280 col: !hasColClasses || !props.cols, 2281 [`col-${props.cols}`]: props.cols, 2282 [`offset-${props.offset}`]: props.offset, 2283 [`order-${props.order}`]: props.order, 2284 [`align-self-${props.alignSelf}`]: props.alignSelf 2285 }); 2286 cache.set(cacheKey, classList); 2287 } 2288 return h(props.tag, (0,_util_mergeData__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP)(data, { 2289 class: classList 2290 }), children); 2291 } 2292})); 2293 2294/***/ }), 2295 2296/***/ 3849: 2297/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2298 2299"use strict"; 2300 2301// EXPORTS 2302__webpack_require__.d(__webpack_exports__, { 2303 Z: function() { return /* binding */ VContainer; } 2304}); 2305 2306// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 2307var web_dom_iterable = __webpack_require__(1181); 2308// EXTERNAL MODULE: ./node_modules/vuetify/src/components/VGrid/_grid.sass 2309var _grid = __webpack_require__(9474); 2310// EXTERNAL MODULE: ./node_modules/vuetify/src/components/VGrid/VGrid.sass 2311var VGrid = __webpack_require__(1959); 2312// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 2313var vue_esm = __webpack_require__(538); 2314;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VGrid/grid.js 2315 2316// Types 2317 2318function grid_VGrid(name) { 2319 /* @vue/component */ 2320 return vue_esm/* default */.ZP.extend({ 2321 name: `v-${name}`, 2322 functional: true, 2323 props: { 2324 id: String, 2325 tag: { 2326 type: String, 2327 default: 'div' 2328 } 2329 }, 2330 render(h, _ref) { 2331 let props = _ref.props, 2332 data = _ref.data, 2333 children = _ref.children; 2334 data.staticClass = `${name} ${data.staticClass || ''}`.trim(); 2335 const attrs = data.attrs; 2336 if (attrs) { 2337 // reset attrs to extract utility clases like pa-3 2338 data.attrs = {}; 2339 const classes = Object.keys(attrs).filter(key => { 2340 // TODO: Remove once resolved 2341 // https://github.com/vuejs/vue/issues/7841 2342 if (key === 'slot') return false;
2343 const value = attrs[key]; // add back data attributes like data-test="foo" but do not 2344 // add them as classes 2345 2346 if (key.startsWith('data-')) { 2347 data.attrs[key] = value; 2348 return false; 2349 } 2350 return value || typeof value === 'string'; 2351 }); 2352 if (classes.length) data.staticClass += ` ${classes.join(' ')}`; 2353 } 2354 if (props.id) { 2355 data.domProps = data.domProps || {}; 2356 data.domProps.id = props.id; 2357 } 2358 return h(props.tag, data, children); 2359 } 2360 }); 2361} 2362// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mergeData.js 2363var mergeData = __webpack_require__(8097); 2364;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VGrid/VContainer.js 2365 2366 2367 2368 2369 2370/* @vue/component */ 2371 2372/* harmony default export */ var VContainer = (grid_VGrid('container').extend({ 2373 name: 'v-container', 2374 functional: true, 2375 props: { 2376 id: String, 2377 tag: { 2378 type: String, 2379 default: 'div' 2380 }, 2381 fluid: { 2382 type: Boolean, 2383 default: false 2384 } 2385 }, 2386 render(h, _ref) { 2387 let props = _ref.props, 2388 data = _ref.data, 2389 children = _ref.children; 2390 let classes; 2391 const attrs = data.attrs; 2392 if (attrs) { 2393 // reset attrs to extract utility clases like pa-3 2394 data.attrs = {}; 2395 classes = Object.keys(attrs).filter(key => { 2396 // TODO: Remove once resolved 2397 // https://github.com/vuejs/vue/issues/7841 2398 if (key === 'slot') return false; 2399 const value = attrs[key]; // add back data attributes like data-test="foo" but do not 2400 // add them as classes 2401 2402 if (key.startsWith('data-')) { 2403 data.attrs[key] = value; 2404 return false; 2405 } 2406 return value || typeof value === 'string'; 2407 }); 2408 } 2409 if (props.id) { 2410 data.domProps = data.domProps || {}; 2411 data.domProps.id = props.id; 2412 } 2413 return h(props.tag, (0,mergeData/* default */.ZP)(data, { 2414 staticClass: 'container', 2415 class: Array({ 2416 'container--fluid': props.fluid 2417 }).concat(classes || []) 2418 }), children); 2419 } 2420})); 2421 2422/***/ }), 2423 2424/***/ 2968: 2425/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2426 2427"use strict"; 2428/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1180); 2429/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9357); 2430/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_0__); 2431/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1181); 2432/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_1__); 2433/* harmony import */ var _src_components_VGrid_VGrid_sass__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1959); 2434/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(538); 2435/* harmony import */ var _util_mergeData__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(8097); 2436/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 2437 2438 2439 2440function 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; } 2441function _objectSpread(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) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEac
2441h(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 2442 2443 2444 2445 // no xs 2446 2447const breakpoints = ['sm', 'md', 'lg', 'xl']; 2448const ALIGNMENT = ['start', 'end', 'center']; 2449function makeProps(prefix, def) { 2450 return breakpoints.reduce((props, val) => { 2451 props[prefix + (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .upperFirst */ .jC)(val)] = def(); 2452 return props; 2453 }, {}); 2454} 2455const alignValidator = str => [...ALIGNMENT, 'baseline', 'stretch'].includes(str); 2456const alignProps = makeProps('align', () => ({ 2457 type: String, 2458 default: null, 2459 validator: alignValidator 2460})); 2461const justifyValidator = str => [...ALIGNMENT, 'space-between', 'space-around'].includes(str); 2462const justifyProps = makeProps('justify', () => ({ 2463 type: String, 2464 default: null, 2465 validator: justifyValidator 2466})); 2467const alignContentValidator = str => [...ALIGNMENT, 'space-between', 'space-around', 'stretch'].includes(str); 2468const alignContentProps = makeProps('alignContent', () => ({ 2469 type: String, 2470 default: null, 2471 validator: alignContentValidator 2472})); 2473const propMap = { 2474 align: Object.keys(alignProps), 2475 justify: Object.keys(justifyProps), 2476 alignContent: Object.keys(alignContentProps) 2477}; 2478const classMap = { 2479 align: 'align', 2480 justify: 'justify', 2481 alignContent: 'align-content' 2482}; 2483function breakpointClass(type, prop, val) { 2484 let className = classMap[type]; 2485 if (val == null) { 2486 return undefined; 2487 } 2488 if (prop) { 2489 // alignSm -> Sm 2490 const breakpoint = prop.replace(type, ''); 2491 className += `-${breakpoint}`; 2492 } // .align-items-sm-center 2493 2494 className += `-${val}`; 2495 return className.toLowerCase(); 2496} 2497const cache = new Map(); 2498/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .ZP.extend({ 2499 name: 'v-row', 2500 functional: true, 2501 props: _objectSpread(_objectSpread(_objectSpread({ 2502 tag: { 2503 type: String, 2504 default: 'div' 2505 }, 2506 dense: Boolean, 2507 noGutters: Boolean,
2508 align: { 2509 type: String, 2510 default: null, 2511 validator: alignValidator 2512 } 2513 }, alignProps), {}, { 2514 justify: { 2515 type: String, 2516 default: null, 2517 validator: justifyValidator 2518 } 2519 }, justifyProps), {}, { 2520 alignContent: { 2521 type: String, 2522 default: null, 2523 validator: alignContentValidator 2524 } 2525 }, alignContentProps), 2526 render(h, _ref) { 2527 let props = _ref.props, 2528 data = _ref.data, 2529 children = _ref.children; 2530 // Super-fast memoization based on props, 5x faster than JSON.stringify 2531 let cacheKey = ''; 2532 for (const prop in props) { 2533 cacheKey += String(props[prop]); 2534 } 2535 let classList = cache.get(cacheKey); 2536 if (!classList) { 2537 classList = []; // Loop through `align`, `justify`, `alignContent` breakpoint props 2538 2539 let type; 2540 for (type in propMap) { 2541 propMap[type].forEach(prop => { 2542 const value = props[prop]; 2543 const className = breakpointClass(type, prop, value); 2544 if (className) classList.push(className); 2545 }); 2546 } 2547 classList.push({ 2548 'no-gutters': props.noGutters, 2549 'row--dense': props.dense, 2550 [`align-${props.align}`]: props.align, 2551 [`justify-${props.justify}`]: props.justify, 2552 [`align-content-${props.alignContent}`]: props.alignContent 2553 }); 2554 cache.set(cacheKey, classList); 2555 } 2556 return h(props.tag, (0,_util_mergeData__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .ZP)(data, { 2557 staticClass: 'row', 2558 class: classList 2559 }), children); 2560 } 2561})); 2562 2563/***/ }), 2564 2565/***/ 2820: 2566/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2567 2568"use strict"; 2569/* harmony import */ var _src_components_VGrid_grid_sass__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9474); 2570/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6539); 2571 2572 2573/* harmony default export */ __webpack_exports__.Z = ((0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .createSimpleFunctional */ .Ji)('spacer', 'div', 'v-spacer')); 2574 2575/***/ }), 2576 2577/***/ 581: 2578/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2579 2580"use strict"; 2581 2582// EXPORTS 2583__webpack_require__.d(__webpack_exports__, { 2584 Z: function() { return /* binding */ VIcon_VIcon; } 2585}); 2586 2587// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 2588var web_dom_iterable = __webpack_require__(1181); 2589// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 2590var defineProperty = __webpack_require__(1180); 2591// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.small.js 2592var es6_string_small = __webpack_require__(3605); 2593;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VIcon/VIcon.sass 2594// extracted by mini-css-extract-plugin 2595 2596// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/binds-attrs/index.js 2597var binds_attrs = __webpack_require__(1679); 2598// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 2599var colorable = __webpack_require__(8390); 2600// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/sizeable/index.js 2601var sizeable = __webpack_require__(2144); 2602// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 2603var themeable = __webpack_require__(7416); 2604// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 2605var helpers = __webpack_require__(6539); 2606// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 2607var vue_esm = __webpack_require__(538); 2608// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 2609var mixins = __webpack_require__(9547); 2610;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VIcon/VIcon.js 2611 2612 2613 2614function 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; } 2615function _objectSpread(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) { (0,defineProperty/* default */.Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEac
2615h(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 2616 // Mixins 2617 2618 2619 2620 2621 // Util 2622 2623 // Types 2624 2625 2626 2627var SIZE_MAP; 2628(function (SIZE_MAP) { 2629 SIZE_MAP["xSmall"] = "12px"; 2630 SIZE_MAP["small"] = "16px"; 2631 SIZE_MAP["default"] = "24px"; 2632 SIZE_MAP["medium"] = "28px"; 2633 SIZE_MAP["large"] = "36px"; 2634 SIZE_MAP["xLarge"] = "40px"; 2635})(SIZE_MAP || (SIZE_MAP = {})); 2636function isFontAwesome5(iconType) { 2637 return ['fas', 'far', 'fal', 'fab', 'fad', 'fak'].some(val => iconType.includes(val)); 2638} 2639function isSvgPath(icon) { 2640 return /^[mzlhvcsqta]\s*[-+.0-9][^mlhvzcsqta]+/i.test(icon) && /[\dz]$/i.test(icon) && icon.length > 4; 2641} 2642const VIcon = (0,mixins/* default */.Z)(binds_attrs/* default */.Z, colorable/* default */.Z, sizeable/* default */.Z, themeable/* default */.Z 2643/* @vue/component */).extend({ 2644 name: 'v-icon', 2645 props: { 2646 dense: Boolean, 2647 disabled: Boolean, 2648 left: Boolean, 2649 right: Boolean, 2650 size: [Number, String], 2651 tag: { 2652 type: String, 2653 required: false, 2654 default: 'i' 2655 } 2656 }, 2657 computed: { 2658 medium() { 2659 return false; 2660 }, 2661 hasClickListener() { 2662 return Boolean(this.listeners$.click || this.listeners$['!click']); 2663 } 2664 }, 2665 methods: { 2666 getIcon() { 2667 let iconName = ''; 2668 if (this.$slots.default) iconName = this.$slots.default[0].text.trim(); 2669 return (0,helpers/* remapInternalIcon */.RB)(this, iconName); 2670 }, 2671 getSize() { 2672 const sizes = { 2673 xSmall: this.xSmall, 2674 small: this.small, 2675 medium: this.medium, 2676 large: this.large, 2677 xLarge: this.xLarge 2678 }; 2679 const explicitSize = (0,helpers/* keys */.XP)(sizes).find(key => sizes[key]); 2680 return explicitSize && SIZE_MAP[explicitSize] || (0,helpers/* convertToUnit */.kb)(this.size); 2681 }, 2682 // Component data for both font icon and SVG wrapper span 2683 getDefaultData() { 2684 return { 2685 staticClass: 'v-icon notranslate', 2686 class: { 2687 'v-icon--disabled': this.disabled, 2688 'v-icon--left': this.left, 2689 'v-icon--link': this.hasClickListener, 2690 'v-icon--right': this.right, 2691 'v-icon--dense': this.dense 2692 }, 2693 attrs: _objectSpread({ 2694 'aria-hidden': !this.hasClickListener, 2695 disabled: this.hasClickListener && this.disabled, 2696 type: this.hasClickListener ? 'button' : undefined 2697 }, this.attrs$), 2698 on: this.listeners$ 2699 }; 2700 }, 2701 getSvgWrapperData() { 2702 const fontSize = this.getSize(); 2703 const wrapperData = _objectSpread(_objectSpread({}, this.getDefaultData()), {}, { 2704 style: fontSize ? { 2705 fontSize, 2706 height: fontSize, 2707 width: fontSize 2708 } : undefined 2709 }); 2710 this.applyColors(wrapperData); 2711 return wrapperData; 2712 }, 2713 applyColors(data) { 2714 data.class = _objectSpread(_objectSpread({}, data.class), this.themeClasses); 2715 this.setTextColor(this.color, data); 2716 }, 2717 renderFontIcon(icon, h) { 2718 const newChildren = []; 2719 const data = this.getDefaultData(); 2720 let iconType = 'material-icons'; // Material Icon delimiter is _ 2721 // https://material.io/icons/ 2722 2723 const delimiterIndex = icon.indexOf('-'); 2724 const isMaterialIcon = delimiterIndex <= -1; 2725 if (isMaterialIcon) { 2726 // Material icon uses ligatures. 2727 newChildren.push(icon); 2728 } else { 2729 iconType = icon.slice(0, delimiterIndex); 2730 if (isFontAwesome5(iconType)) iconType = ''; 2731 } 2732 data.class[iconType] = true; 2733 data.class[icon] = !isMaterialIcon; 2734 const fontSize = this.getSize(); 2735 if (fontSize) data.style = { 2736 fontSize 2737 }; 2738 this.applyColors(data); 2739 return h(this.hasClickListener ? 'button' : this.tag, data, newChildren); 2740 }, 2741 renderSvgIcon(icon, h) { 2742 const svgData = { 2743 class: 'v-icon__svg', 2744 attrs: { 2745 xmlns: 'http://www.w3.org/2000/svg',
2746 viewBox: '0 0 24 24', 2747 role: 'img', 2748 'aria-hidden': true 2749 } 2750 }; 2751 const size = this.getSize(); 2752 if (size) { 2753 svgData.style = { 2754 fontSize: size, 2755 height: size, 2756 width: size 2757 }; 2758 } 2759 return h(this.hasClickListener ? 'button' : 'span', this.getSvgWrapperData(), [h('svg', svgData, [h('path', { 2760 attrs: { 2761 d: icon 2762 } 2763 })])]); 2764 }, 2765 renderSvgIconComponent(icon, h) { 2766 const data = { 2767 class: { 2768 'v-icon__component': true 2769 } 2770 }; 2771 const size = this.getSize(); 2772 if (size) { 2773 data.style = { 2774 fontSize: size, 2775 height: size, 2776 width: size 2777 }; 2778 } 2779 this.applyColors(data); 2780 const component = icon.component; 2781 data.props = icon.props; 2782 data.nativeOn = data.on; 2783 return h(this.hasClickListener ? 'button' : 'span', this.getSvgWrapperData(), [h(component, data)]); 2784 } 2785 }, 2786 render(h) { 2787 const icon = this.getIcon(); 2788 if (typeof icon === 'string') { 2789 if (isSvgPath(icon)) { 2790 return this.renderSvgIcon(icon, h); 2791 } 2792 return this.renderFontIcon(icon, h); 2793 } 2794 return this.renderSvgIconComponent(icon, h); 2795 } 2796}); 2797/* harmony default export */ var VIcon_VIcon = (vue_esm/* default */.ZP.extend({ 2798 name: 'v-icon', 2799 $_wrapperFor: VIcon, 2800 functional: true, 2801 render(h, _ref) { 2802 let data = _ref.data, 2803 children = _ref.children; 2804 let iconName = ''; // Support usage of v-text and v-html 2805 2806 if (data.domProps) { 2807 iconName = data.domProps.textContent || data.domProps.innerHTML || iconName; // Remove nodes so it doesn't 2808 // overwrite our changes 2809 2810 delete data.domProps.textContent; 2811 delete data.domProps.innerHTML; 2812 } 2813 return h(VIcon, data, iconName ? [iconName] : children); 2814 } 2815})); 2816 2817/***/ }), 2818 2819/***/ 9548: 2820/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2821 2822"use strict"; 2823/* harmony import */ var _VIcon__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(581); 2824 2825 2826/* harmony default export */ __webpack_exports__.Z = (_VIcon__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z); 2827 2828/***/ }), 2829 2830/***/ 5937: 2831/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 2832 2833"use strict"; 2834 2835// EXPORTS 2836__webpack_require__.d(__webpack_exports__, { 2837 Z: function() { return /* binding */ VImg; } 2838}); 2839 2840;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VImg/VImg.sass 2841// extracted by mini-css-extract-plugin 2842 2843// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/intersect/index.js 2844var intersect = __webpack_require__(9106); 2845;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VResponsive/VResponsive.sass 2846// extracted by mini-css-extract-plugin 2847 2848// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/measurable/index.js 2849var measurable = __webpack_require__(8888); 2850// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 2851var mixins = __webpack_require__(9547); 2852// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 2853var helpers = __webpack_require__(6539); 2854;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VResponsive/VResponsive.js 2855 // Mixins 2856 2857 // Utils 2858 2859 2860 2861/* @vue/component */ 2862 2863/* harmony default export */ var VResponsive = ((0,mixins/* default */.Z)(measurable/* default */.Z).extend({ 2864 name: 'v-responsive', 2865 props: { 2866 aspectRatio: [String, Number], 2867 contentClass: String 2868 }, 2869 computed: { 2870 computedAspectRatio() { 2871 return Number(this.aspectRatio); 2872 }, 2873 aspectStyle() { 2874 return this.computedAspectRatio ? { 2875 paddingBottom: 1 / this.computedAspectRatio * 100 + '%' 2876 } : undefined; 2877 }, 2878 __cachedSizer() { 2879 if (!this.aspectStyle) return []; 2880 return this.$createElement('div', { 2881 style: this.aspectStyle, 2882 staticClass: 'v-responsive__sizer' 2883 }); 2884 } 2885 }, 2886 methods: { 2887 genContent() { 2888 return this.$createElement('div', { 2889 staticClass: 'v-responsive__content', 2890 class: this.contentClass 2891 }, (0,helpers/* getSlot */.z9)(this)); 2892 } 2893 }, 2894 render(h) { 2895 return h('div', { 2896 staticClass: 'v-responsive', 2897 style: this.measurableStyles, 2898 on: this.$listeners 2899 }, [this.__cachedSizer, this.genContent()]); 2900 } 2901})); 2902;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VResponsive/index.js 2903 2904 2905/* harmony default export */ var components_VResponsive = (VResponsive); 2906// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 2907var themeable = __webpack_require__(7416); 2908// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mergeData.js 2909var mergeData = __webpack_require__(8097); 2910// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 2911var console = __webpack_require__(9206); 2912;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VImg/VImg.js 2913// Styles 2914 // Directives 2915 2916 // Components 2917 2918 // Mixins 2919 2920 // Utils 2921 2922 2923 2924 2925 2926const hasIntersect = typeof window !== 'undefined' && 'IntersectionObserver' in window; 2927/* @vue/component */ 2928 2929/* harmony default export */ var VImg = ((0,mixins/* default */.Z)(components_VResponsive, themeable/* default */.Z).extend({ 2930 name: 'v-img', 2931 directives: { 2932 intersect: intersect/* default */.Z 2933 }, 2934 props: { 2935 alt: String, 2936 contain: Boolean, 2937 eager: Boolean, 2938 gradient: String, 2939 lazySrc: String, 2940 options: { 2941 type: Object, 2942 // For more information on types, navigate to: 2943 // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API 2944 default: () => ({ 2945 root: undefined, 2946 rootMargin: undefined, 2947 threshold: undefined 2948 }) 2949 }, 2950 position: { 2951 type: String, 2952 default: 'center center' 2953 }, 2954 sizes: String, 2955 src: { 2956 type: [String, Object], 2957 default: '' 2958 }, 2959 srcset: String, 2960 transition: { 2961 type: [Boolean, String], 2962 default: 'fade-transition' 2963 } 2964 }, 2965 data() { 2966 return { 2967 currentSrc: '', 2968 image: null, 2969 isLoading: true, 2970 calculatedAspectRatio: undefined,
2971 naturalWidth: undefined, 2972 hasError: false 2973 }; 2974 }, 2975 computed: { 2976 computedAspectRatio() { 2977 return Number(this.normalisedSrc.aspect || this.calculatedAspectRatio); 2978 }, 2979 normalisedSrc() { 2980 return this.src && typeof this.src === 'object' ? { 2981 src: this.src.src, 2982 srcset: this.srcset || this.src.srcset, 2983 lazySrc: this.lazySrc || this.src.lazySrc, 2984 aspect: Number(this.aspectRatio || this.src.aspect) 2985 } : { 2986 src: this.src, 2987 srcset: this.srcset, 2988 lazySrc: this.lazySrc, 2989 aspect: Number(this.aspectRatio || 0) 2990 }; 2991 }, 2992 __cachedImage() { 2993 if (!(this.normalisedSrc.src || this.normalisedSrc.lazySrc || this.gradient)) return []; 2994 const backgroundImage = []; 2995 const src = this.isLoading ? this.normalisedSrc.lazySrc : this.currentSrc; 2996 if (this.gradient) backgroundImage.push(`linear-gradient(${this.gradient})`); 2997 if (src) backgroundImage.push(`url("${src}")`); 2998 const image = this.$createElement('div', { 2999 staticClass: 'v-image__image', 3000 class: { 3001 'v-image__image--preload': this.isLoading, 3002 'v-image__image--contain': this.contain, 3003 'v-image__image--cover': !this.contain 3004 }, 3005 style: { 3006 backgroundImage: backgroundImage.join(', '), 3007 backgroundPosition: this.position 3008 }, 3009 key: +this.isLoading 3010 }); 3011 /* istanbul ignore if */ 3012 3013 if (!this.transition) return image; 3014 return this.$createElement('transition', { 3015 attrs: { 3016 name: this.transition, 3017 mode: 'in-out' 3018 } 3019 }, [image]); 3020 } 3021 }, 3022 watch: { 3023 src() { 3024 // Force re-init when src changes 3025 if (!this.isLoading) this.init(undefined, undefined, true);else this.loadImage(); 3026 }, 3027 '$vuetify.breakpoint.width': 'getSrc' 3028 }, 3029 mounted() { 3030 this.init(); 3031 }, 3032 methods: { 3033 init(entries, observer, isIntersecting) { 3034 // If the current browser supports the intersection 3035 // observer api, the image is not observable, and 3036 // the eager prop isn't being used, do not load 3037 if (hasIntersect && !isIntersecting && !this.eager) return; 3038 if (this.normalisedSrc.lazySrc) { 3039 const lazyImg = new Image(); 3040 lazyImg.src = this.normalisedSrc.lazySrc; 3041 this.pollForSize(lazyImg, null); 3042 } 3043 /* istanbul ignore else */ 3044 3045 if (this.normalisedSrc.src) this.loadImage(); 3046 }, 3047 onLoad() {
3048 this.getSrc(); 3049 this.isLoading = false; 3050 this.$emit('load', this.src); 3051 if (this.image && (this.normalisedSrc.src.endsWith('.svg') || this.normalisedSrc.src.startsWith('data:image/svg+xml'))) { 3052 if (this.image.naturalHeight && this.image.naturalWidth) { 3053 this.naturalWidth = this.image.naturalWidth; 3054 this.calculatedAspectRatio = this.image.naturalWidth / this.image.naturalHeight; 3055 } else { 3056 this.calculatedAspectRatio = 1; 3057 } 3058 } 3059 }, 3060 onError() { 3061 this.hasError = true; 3062 this.$emit('error', this.src); 3063 }, 3064 getSrc() { 3065 /* istanbul ignore else */ 3066 if (this.image) this.currentSrc = this.image.currentSrc || this.image.src; 3067 }, 3068 loadImage() { 3069 const image = new Image(); 3070 this.image = image; 3071 image.onload = () => { 3072 /* istanbul ignore if */ 3073 if (image.decode) { 3074 image.decode().catch(err => { 3075 (0,console/* consoleWarn */.Kd)(`Failed to decode image, trying to render anyway\n\n` + `src: ${this.normalisedSrc.src}` + (err.message ? `\nOriginal error: ${err.message}` : ''), this); 3076 }).then(this.onLoad); 3077 } else { 3078 this.onLoad(); 3079 } 3080 }; 3081 image.onerror = this.onError; 3082 this.hasError = false; 3083 this.sizes && (image.sizes = this.sizes); 3084 this.normalisedSrc.srcset && (image.srcset = this.normalisedSrc.srcset); 3085 image.src = this.normalisedSrc.src; 3086 this.$emit('loadstart', this.normalisedSrc.src); 3087 this.aspectRatio || this.pollForSize(image);
3088 this.getSrc(); 3089 }, 3090 pollForSize(img) { 3091 let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100; 3092 const poll = () => { 3093 const naturalHeight = img.naturalHeight, 3094 naturalWidth = img.naturalWidth; 3095 if (naturalHeight || naturalWidth) { 3096 this.naturalWidth = naturalWidth; 3097 this.calculatedAspectRatio = naturalWidth / naturalHeight; 3098 } else if (!img.complete && this.isLoading && !this.hasError && timeout != null) { 3099 setTimeout(poll, timeout); 3100 } 3101 }; 3102 poll(); 3103 }, 3104 genContent() { 3105 const content = components_VResponsive.options.methods.genContent.call(this); 3106 if (this.naturalWidth) { 3107 this._b(content.data, 'div', { 3108 style: { 3109 width: `${this.naturalWidth}px` 3110 } 3111 }); 3112 } 3113 return content; 3114 }, 3115 __genPlaceholder() { 3116 const slot = (0,helpers/* getSlot */.z9)(this, 'placeholder'); 3117 if (slot) { 3118 const placeholder = this.isLoading ? [this.$createElement('div', { 3119 staticClass: 'v-image__placeholder' 3120 }, slot)] : []; 3121 if (!this.transition) return placeholder[0]; 3122 return this.$createElement('transition', { 3123 props: { 3124 appear: true, 3125 name: this.transition 3126 } 3127 }, placeholder); 3128 } 3129 } 3130 }, 3131 render(h) { 3132 const node = components_VResponsive.options.render.call(this, h); 3133 const data = (0,mergeData/* default */.ZP)(node.data, { 3134 staticClass: 'v-image', 3135 attrs: { 3136 'aria-label': this.alt, 3137 role: this.alt ? 'img' : undefined 3138 }, 3139 class: this.themeClasses, 3140 // Only load intersect directive if it 3141 // will work in the current browser. 3142 directives: hasIntersect ? [{ 3143 name: 'intersect', 3144 modifiers: { 3145 once: true 3146 }, 3147 value: { 3148 handler: this.init, 3149 options: this.options 3150 } 3151 }] : undefined 3152 }); 3153 node.children = [this.__cachedSizer, this.__cachedImage, this.__genPlaceholder(), this.genContent()]; 3154 return h(node.tag, data, node.children); 3155 } 3156})); 3157 3158/***/ }), 3159 3160/***/ 1591: 3161/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 3162 3163"use strict"; 3164 3165// EXPORTS 3166__webpack_require__.d(__webpack_exports__, { 3167 Z: function() { return /* binding */ components_VInput; } 3168}); 3169 3170// UNUSED EXPORTS: VInput 3171 3172// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 3173var web_dom_iterable = __webpack_require__(1181); 3174// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 3175var defineProperty = __webpack_require__(1180); 3176;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VInput/VInput.sass 3177// extracted by mini-css-extract-plugin 3178 3179// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VIcon/index.js 3180var VIcon = __webpack_require__(9548); 3181// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VLabel/index.js + 2 modules 3182var VLabel = __webpack_require__(8877); 3183;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VMessages/VMessages.sass 3184// extracted by mini-css-extract-plugin 3185 3186// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 3187var colorable = __webpack_require__(8390); 3188// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 3189var themeable = __webpack_require__(7416); 3190// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 3191var mixins = __webpack_require__(9547); 3192// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 3193var helpers = __webpack_require__(6539); 3194;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VMessages/VMessages.js 3195// Styles 3196 // Mixins 3197 3198 3199 3200 // Utilities 3201 3202 3203/* @vue/component */ 3204 3205/* harmony default export */ var VMessages = ((0,mixins/* default */.Z)(colorable/* default */.Z, themeable/* default */.Z).extend({ 3206 name: 'v-messages', 3207 props: { 3208 value: { 3209 type: Array, 3210 default: () => [] 3211 } 3212 }, 3213 methods: { 3214 genChildren() { 3215 return this.$createElement('transition-group', { 3216 staticClass: 'v-messages__wrapper', 3217 attrs: { 3218 name: 'message-transition', 3219 tag: 'div' 3220 } 3221 }, this.value.map(this.genMessage)); 3222 }, 3223 genMessage(message, key) { 3224 return this.$createElement('div', { 3225 staticClass: 'v-messages__message', 3226 key 3227 }, (0,helpers/* getSlot */.z9)(this, 'default', { 3228 message, 3229 key 3230 }) || [message]); 3231 } 3232 }, 3233 render(h) { 3234 return h('div', this.setTextColor(this.color, { 3235 staticClass: 'v-messages', 3236 class: this.themeClasses 3237 }), [this.genChildren()]); 3238 } 3239})); 3240;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VMessages/index.js 3241 3242 3243/* harmony default export */ var components_VMessages = (VMessages); 3244// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/binds-attrs/index.js 3245var binds_attrs = __webpack_require__(1679); 3246// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/validatable/index.js 3247var validatable = __webpack_require__(7123); 3248// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mergeData.js 3249var mergeData = __webpack_require__(8097); 3250;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VInput/VInput.js 3251 3252 3253function 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; } 3254function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
3254 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 3255// Styles 3256 // Components 3257 3258 3259 3260 // Mixins 3261 3262 3263 // Utilities 3264 3265 3266 3267 3268const baseMixins = (0,mixins/* default */.Z)(binds_attrs/* default */.Z, validatable/* default */.Z); 3269/* @vue/component */ 3270 3271/* harmony default export */ var VInput = (baseMixins.extend().extend({ 3272 name: 'v-input', 3273 inheritAttrs: false, 3274 props: { 3275 appendIcon: String, 3276 backgroundColor: { 3277 type: String, 3278 default: '' 3279 }, 3280 dense: Boolean, 3281 height: [Number, String], 3282 hideDetails: [Boolean, String], 3283 hideSpinButtons: Boolean, 3284 hint: String, 3285 id: String, 3286 label: String, 3287 loading: Boolean, 3288 persistentHint: Boolean, 3289 prependIcon: String, 3290 value: null 3291 }, 3292 data() { 3293 return { 3294 lazyValue: this.value, 3295 hasMouseDown: false 3296 }; 3297 }, 3298 computed: { 3299 classes() { 3300 return _objectSpread({ 3301 'v-input--has-state': this.hasState,
3302 'v-input--hide-details': !this.showDetails, 3303 'v-input--is-label-active': this.isLabelActive, 3304 'v-input--is-dirty': this.isDirty, 3305 'v-input--is-disabled': this.isDisabled, 3306 'v-input--is-focused': this.isFocused, 3307 // <v-switch loading>.loading === '' so we can't just cast to boolean 3308 'v-input--is-loading': this.loading !== false && this.loading != null, 3309 'v-input--is-readonly': this.isReadonly, 3310 'v-input--dense': this.dense, 3311 'v-input--hide-spin-buttons': this.hideSpinButtons 3312 }, this.themeClasses); 3313 }, 3314 computedId() { 3315 return this.id || `input-${this._uid}`; 3316 }, 3317 hasDetails() { 3318 return this.messagesToDisplay.length > 0; 3319 }, 3320 hasHint() { 3321 return !this.hasMessages && !!this.hint && (this.persistentHint || this.isFocused); 3322 }, 3323 hasLabel() { 3324 return !!(this.$slots.label || this.label); 3325 }, 3326 // Proxy for `lazyValue` 3327 // This allows an input 3328 // to function without 3329 // a provided model 3330 internalValue: { 3331 get() { 3332 return this.lazyValue; 3333 }, 3334 set(val) { 3335 this.lazyValue = val; 3336 this.$emit(this.$_modelEvent, val); 3337 } 3338 }, 3339 isDirty() { 3340 return !!this.lazyValue; 3341 }, 3342 isLabelActive() { 3343 return this.isDirty; 3344 }, 3345 messagesToDisplay() { 3346 if (this.hasHint) return [this.hint]; 3347 if (!this.hasMessages) return []; 3348 return this.validations.map(validation => { 3349 if (typeof validation === 'string') return validation; 3350 const validationResult = validation(this.internalValue); 3351 return typeof validationResult === 'string' ? validationResult : ''; 3352 }).filter(message => message !== ''); 3353 }, 3354 showDetails() { 3355 return this.hideDetails === false || this.hideDetails === 'auto' && this.hasDetails; 3356 } 3357 }, 3358 watch: { 3359 value(val) { 3360 this.lazyValue = val; 3361 } 3362 }, 3363 beforeCreate() { 3364 // v-radio-group needs to emit a different event 3365 // https://github.com/vuetifyjs/vuetify/issues/4752 3366 this.$_modelEvent = this.$options.model && this.$options.model.event || 'input'; 3367 }, 3368 methods: { 3369 genContent() { 3370 return [this.genPrependSlot(), this.genControl(), this.genAppendSlot()]; 3371 }, 3372 genControl() { 3373 return this.$createElement('div', { 3374 staticClass: 'v-input__control', 3375 attrs: { 3376 title: this.attrs$.title 3377 } 3378 }, [this.genInputSlot(), this.genMessages()]); 3379 }, 3380 genDefaultSlot() { 3381 return [this.genLabel(), this.$slots.default]; 3382 }, 3383 genIcon(type, cb) { 3384 let extraData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 3385 var _a; 3386 const icon = this[`${type}Icon`]; 3387 const eventName = `click:${(0,helpers/* kebabCase */.GL)(type)}`; 3388 const hasListener = !!(this.listeners$[eventName] || cb); 3389 const localeKey = { 3390 prepend: 'prependAction', 3391 prependInner: 'prependAction', 3392 append: 'appendAction', 3393 appendOuter: 'appendAction', 3394 clear: 'clear' 3395 }[type]; 3396 const label = hasListener && localeKey ? this.$vuetify.lang.t(`$vuetify.input.${localeKey}`, (_a = this.label) !== null && _a !== void 0 ? _a : '') : undefined; 3397 const data = (0,mergeData/* default */.ZP)({ 3398 attrs: { 3399 'aria-label': label, 3400 color: this.validationState, 3401 dark: this.dark, 3402 disabled: this.isDisabled, 3403 light: this.light, 3404 tabindex: type === 'clear' ? -1 : undefined 3405 }, 3406 on: !hasListener ? undefined : { 3407 click: e => { 3408 e.preventDefault(); 3409 e.stopPropagation(); 3410 this.$emit(eventName, e); 3411 cb && cb(e); 3412 }, 3413 // Container has g event that will 3414 // trigger menu open if enclosed 3415 mouseup: e => { 3416 e.preventDefault(); 3417 e.stopPropagation(); 3418 } 3419 } 3420 }, extraData); 3421 return this.$createElement('div', { 3422 staticClass: `v-input__icon`, 3423 class: type ? `v-input__icon--${(0,helpers/* kebabCase */.GL)(type)}` : undefined 3424 }, [this.$createElement(VIcon/* default */.Z, data, icon)]); 3425 }, 3426 genInputSlot() {
3427 return this.$createElement('div', this.setBackgroundColor(this.backgroundColor, { 3428 staticClass: 'v-input__slot', 3429 style: { 3430 height: (0,helpers/* convertToUnit */.kb)(this.height) 3431 }, 3432 on: { 3433 click: this.onClick, 3434 mousedown: this.onMouseDown, 3435 mouseup: this.onMouseUp 3436 }, 3437 ref: 'input-slot' 3438 }), [this.genDefaultSlot()]); 3439 }, 3440 genLabel() { 3441 if (!this.hasLabel) return null; 3442 return this.$createElement(VLabel/* default */.Z, { 3443 props: { 3444 color: this.validationState, 3445 dark: this.dark, 3446 disabled: this.isDisabled, 3447 focused: this.hasState, 3448 for: this.computedId, 3449 light: this.light 3450 } 3451 }, this.$slots.label || this.label); 3452 }, 3453 genMessages() { 3454 if (!this.showDetails) return null; 3455 return this.$createElement(components_VMessages, { 3456 props: { 3457 color: this.hasHint ? '' : this.validationState, 3458 dark: this.dark, 3459 light: this.light, 3460 value: this.messagesToDisplay 3461 }, 3462 attrs: { 3463 role: this.hasMessages ? 'alert' : null 3464 }, 3465 scopedSlots: { 3466 default: props => (0,helpers/* getSlot */.z9)(this, 'message', props) 3467 } 3468 }); 3469 }, 3470 genSlot(type, location, slot) { 3471 if (!slot.length) return null; 3472 const ref = `${type}-${location}`; 3473 return this.$createElement('div', { 3474 staticClass: `v-input__${ref}`, 3475 ref 3476 }, slot); 3477 }, 3478 genPrependSlot() { 3479 const slot = []; 3480 if (this.$slots.prepend) { 3481 slot.push(this.$slots.prepend); 3482 } else if (this.prependIcon) { 3483 slot.push(this.genIcon('prepend')); 3484 } 3485 return this.genSlot('prepend', 'outer', slot); 3486 }, 3487 genAppendSlot() { 3488 const slot = []; // Append icon for text field was really 3489 // an appended inner icon, v-text-field 3490 // will overwrite this method in order to obtain 3491 // backwards compat 3492 3493 if (this.$slots.append) { 3494 slot.push(this.$slots.append); 3495 } else if (this.appendIcon) { 3496 slot.push(this.genIcon('append')); 3497 } 3498 return this.genSlot('append', 'outer', slot); 3499 }, 3500 onClick(e) { 3501 this.$emit('click', e); 3502 }, 3503 onMouseDown(e) { 3504 this.hasMouseDown = true; 3505 this.$emit('mousedown', e); 3506 }, 3507 onMouseUp(e) { 3508 this.hasMouseDown = false; 3509 this.$emit('mouseup', e); 3510 } 3511 }, 3512 render(h) { 3513 return h('div', this.setTextColor(this.validationState, { 3514 staticClass: 'v-input', 3515 class: this.classes 3516 }), this.genContent()); 3517 } 3518})); 3519;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VInput/index.js 3520 3521 3522/* harmony default export */ var components_VInput = (VInput); 3523 3524/***/ }), 3525 3526/***/ 8877: 3527/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 3528 3529"use strict"; 3530 3531// EXPORTS 3532__webpack_require__.d(__webpack_exports__, { 3533 Z: function() { return /* binding */ components_VLabel; } 3534}); 3535 3536// UNUSED EXPORTS: VLabel 3537 3538// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 3539var web_dom_iterable = __webpack_require__(1181); 3540// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 3541var defineProperty = __webpack_require__(1180); 3542;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VLabel/VLabel.sass 3543// extracted by mini-css-extract-plugin 3544 3545// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 3546var colorable = __webpack_require__(8390); 3547// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 3548var themeable = __webpack_require__(7416); 3549// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 3550var mixins = __webpack_require__(9547); 3551// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 3552var helpers = __webpack_require__(6539); 3553// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mergeData.js 3554var mergeData = __webpack_require__(8097); 3555;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VLabel/VLabel.js 3556 3557 3558function 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; } 3559function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
3559 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 3560// Styles 3561 // Mixins 3562 3563 3564 3565 // Helpers 3566 3567 3568 3569/* @vue/component */ 3570 3571/* harmony default export */ var VLabel = ((0,mixins/* default */.Z)(themeable/* default */.Z).extend({ 3572 name: 'v-label', 3573 functional: true, 3574 props: { 3575 absolute: Boolean, 3576 color: { 3577 type: String, 3578 default: 'primary' 3579 }, 3580 disabled: Boolean, 3581 focused: Boolean, 3582 for: String, 3583 left: { 3584 type: [Number, String], 3585 default: 0 3586 }, 3587 right: { 3588 type: [Number, String], 3589 default: 'auto' 3590 }, 3591 value: Boolean 3592 }, 3593 render(h, ctx) { 3594 const children = ctx.children, 3595 listeners = ctx.listeners, 3596 props = ctx.props, 3597 data = ctx.data; 3598 const newData = (0,mergeData/* default */.ZP)({ 3599 staticClass: 'v-label', 3600 class: _objectSpread({ 3601 'v-label--active': props.value, 3602 'v-label--is-disabled': props.disabled 3603 }, (0,themeable/* functionalThemeClasses */.X)(ctx)), 3604 attrs: { 3605 for: props.for, 3606 'aria-hidden': !props.for 3607 }, 3608 on: listeners, 3609 style: { 3610 left: (0,helpers/* convertToUnit */.kb)(props.left), 3611 right: (0,helpers/* convertToUnit */.kb)(props.right), 3612 position: props.absolute ? 'absolute' : 'relative' 3613 }, 3614 ref: 'label' 3615 }, data); 3616 return h('label', colorable/* default */.Z.options.methods.setTextColor(props.focused && props.color, newData), children); 3617 } 3618})); 3619;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VLabel/index.js 3620 3621 3622/* harmony default export */ var components_VLabel = (VLabel); 3623 3624/***/ }), 3625 3626/***/ 8786: 3627/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 3628 3629"use strict"; 3630 3631// EXPORTS 3632__webpack_require__.d(__webpack_exports__, { 3633 Z: function() { return /* binding */ VMain; } 3634}); 3635 3636;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VMain/VMain.sass 3637// extracted by mini-css-extract-plugin 3638 3639// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/ssr-bootable/index.js 3640var ssr_bootable = __webpack_require__(4425); 3641;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VMain/VMain.js 3642// Styles 3643 // Mixins 3644 3645 3646/* @vue/component */ 3647 3648/* harmony default export */ var VMain = (ssr_bootable/* default */.Z.extend({ 3649 name: 'v-main', 3650 props: { 3651 tag: { 3652 type: String, 3653 default: 'main' 3654 } 3655 }, 3656 computed: { 3657 styles() { 3658 const _this$$vuetify$applic = this.$vuetify.application, 3659 bar = _this$$vuetify$applic.bar, 3660 top = _this$$vuetify$applic.top, 3661 right = _this$$vuetify$applic.right, 3662 footer = _this$$vuetify$applic.footer, 3663 insetFooter = _this$$vuetify$applic.insetFooter, 3664 bottom = _this$$vuetify$applic.bottom, 3665 left = _this$$vuetify$applic.left; 3666 return { 3667 paddingTop: `${top + bar}px`, 3668 paddingRight: `${right}px`, 3669 paddingBottom: `${footer + insetFooter + bottom}px`, 3670 paddingLeft: `${left}px` 3671 }; 3672 } 3673 }, 3674 render(h) { 3675 const data = { 3676 staticClass: 'v-main', 3677 style: this.styles, 3678 ref: 'main' 3679 }; 3680 return h(this.tag, data, [h('div', { 3681 staticClass: 'v-main__wrap' 3682 }, this.$slots.default)]); 3683 } 3684})); 3685 3686/***/ }), 3687 3688/***/ 8842: 3689/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 3690 3691"use strict"; 3692 3693// EXPORTS 3694__webpack_require__.d(__webpack_exports__, { 3695 Z: function() { return /* binding */ VProgressCircular; } 3696}); 3697 3698;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VProgressCircular/VProgressCircular.sass 3699// extracted by mini-css-extract-plugin 3700 3701// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/intersect/index.js 3702var intersect = __webpack_require__(9106); 3703// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 3704var colorable = __webpack_require__(8390); 3705// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 3706var helpers = __webpack_require__(6539); 3707;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VProgressCircular/VProgressCircular.js 3708// Styles 3709 // Directives 3710 3711 // Mixins 3712 3713 // Utils 3714 3715 3716/* @vue/component */ 3717 3718/* harmony default export */ var VProgressCircular = (colorable/* default */.Z.extend({ 3719 name: 'v-progress-circular', 3720 directives: { 3721 intersect: intersect/* default */.Z 3722 }, 3723 props: { 3724 button: Boolean, 3725 indeterminate: Boolean, 3726 rotate: { 3727 type: [Number, String], 3728 default: 0 3729 }, 3730 size: { 3731 type: [Number, String], 3732 default: 32 3733 }, 3734 width: { 3735 type: [Number, String], 3736 default: 4 3737 }, 3738 value: { 3739 type: [Number, String], 3740 default: 0 3741 } 3742 }, 3743 data: () => ({ 3744 radius: 20, 3745 isVisible: true 3746 }), 3747 computed: { 3748 calculatedSize() { 3749 return Number(this.size) + (this.button ? 8 : 0); 3750 }, 3751 circumference() { 3752 return 2 * Math.PI * this.radius; 3753 }, 3754 classes() { 3755 return { 3756 'v-progress-circular--visible': this.isVisible, 3757 'v-progress-circular--indeterminate': this.indeterminate, 3758 'v-progress-circular--button': this.button 3759 }; 3760 }, 3761 normalizedValue() { 3762 if (this.value < 0) { 3763 return 0; 3764 } 3765 if (this.value > 100) { 3766 return 100; 3767 } 3768 return parseFloat(this.value); 3769 }, 3770 strokeDashArray() { 3771 return Math.round(this.circumference * 1000) / 1000; 3772 }, 3773 strokeDashOffset() { 3774 return (100 - this.normalizedValue) / 100 * this.circumference + 'px'; 3775 }, 3776 strokeWidth() { 3777 return Number(this.width) / +this.size * this.viewBoxSize * 2; 3778 }, 3779 styles() { 3780 return { 3781 height: (0,helpers/* convertToUnit */.kb)(this.calculatedSize), 3782 width: (0,helpers/* convertToUnit */.kb)(this.calculatedSize) 3783 }; 3784 }, 3785 svgStyles() { 3786 return { 3787 transform: `rotate(${Number(this.rotate)}deg)` 3788 }; 3789 },
3790 viewBoxSize() { 3791 return this.radius / (1 - Number(this.width) / +this.size); 3792 } 3793 }, 3794 methods: { 3795 genCircle(name, offset) { 3796 return this.$createElement('circle', { 3797 class: `v-progress-circular__${name}`, 3798 attrs: { 3799 fill: 'transparent', 3800 cx: 2 * this.viewBoxSize, 3801 cy: 2 * this.viewBoxSize, 3802 r: this.radius, 3803 'stroke-width': this.strokeWidth, 3804 'stroke-dasharray': this.strokeDashArray, 3805 'stroke-dashoffset': offset 3806 } 3807 }); 3808 }, 3809 genSvg() { 3810 const children = [this.indeterminate || this.genCircle('underlay', 0), this.genCircle('overlay', this.strokeDashOffset)]; 3811 return this.$createElement('svg', { 3812 style: this.svgStyles, 3813 attrs: { 3814 xmlns: 'http://www.w3.org/2000/svg', 3815 viewBox: `${this.viewBoxSize} ${this.viewBoxSize} ${2 * this.viewBoxSize} ${2 * this.viewBoxSize}` 3816 } 3817 }, children); 3818 }, 3819 genInfo() { 3820 return this.$createElement('div', { 3821 staticClass: 'v-progress-circular__info' 3822 }, this.$slots.default); 3823 }, 3824 onObserve(entries, observer, isIntersecting) { 3825 this.isVisible = isIntersecting; 3826 } 3827 }, 3828 render(h) { 3829 return h('div', this.setTextColor(this.color, { 3830 staticClass: 'v-progress-circular', 3831 attrs: { 3832 role: 'progressbar', 3833 'aria-valuemin': 0, 3834 'aria-valuemax': 100, 3835 'aria-valuenow': this.indeterminate ? undefined : this.normalizedValue 3836 }, 3837 class: this.classes, 3838 directives: [{ 3839 name: 'intersect', 3840 value: this.onObserve 3841 }], 3842 style: this.styles, 3843 on: this.$listeners 3844 }), [this.genSvg(), this.genInfo()]); 3845 } 3846})); 3847 3848/***/ }), 3849 3850/***/ 9393: 3851/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 3852 3853"use strict"; 3854 3855// EXPORTS 3856__webpack_require__.d(__webpack_exports__, { 3857 Z: function() { return /* binding */ VProgressLinear; } 3858}); 3859 3860// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 3861var web_dom_iterable = __webpack_require__(1181); 3862// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.fixed.js 3863var es6_string_fixed = __webpack_require__(5177); 3864// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 3865var defineProperty = __webpack_require__(1180); 3866;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VProgressLinear/VProgressLinear.sass 3867// extracted by mini-css-extract-plugin 3868 3869// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/transitions/index.js + 2 modules 3870var transitions = __webpack_require__(5712); 3871// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/intersect/index.js 3872var intersect = __webpack_require__(9106); 3873// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 3874var colorable = __webpack_require__(8390); 3875// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/positionable/index.js 3876var positionable = __webpack_require__(4287); 3877// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/proxyable/index.js 3878var proxyable = __webpack_require__(8747); 3879// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 3880var themeable = __webpack_require__(7416); 3881// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 3882var helpers = __webpack_require__(6539); 3883// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 3884var mixins = __webpack_require__(9547); 3885;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.js 3886 3887 3888 3889function 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; } 3890function _objectSpread(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) { (0,defineProperty/* default */.Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEac
3890h(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 3891 // Components 3892 3893 // Directives 3894 3895 // Mixins 3896 3897 3898 3899 3900 // Utilities 3901 3902 3903 3904const baseMixins = (0,mixins/* default */.Z)(colorable/* default */.Z, (0,positionable/* factory */.d)(['absolute', 'fixed', 'top', 'bottom']), proxyable/* default */.Z, themeable/* default */.Z); 3905/* @vue/component */ 3906 3907/* harmony default export */ var VProgressLinear = (baseMixins.extend({ 3908 name: 'v-progress-linear', 3909 directives: { 3910 intersect: intersect/* default */.Z 3911 }, 3912 props: { 3913 active: { 3914 type: Boolean, 3915 default: true 3916 }, 3917 backgroundColor: { 3918 type: String, 3919 default: null 3920 }, 3921 backgroundOpacity: { 3922 type: [Number, String], 3923 default: null 3924 }, 3925 bufferValue: { 3926 type: [Number, String], 3927 default: 100 3928 }, 3929 color: { 3930 type: String, 3931 default: 'primary' 3932 }, 3933 height: { 3934 type: [Number, String], 3935 default: 4 3936 }, 3937 indeterminate: Boolean, 3938 query: Boolean, 3939 reverse: Boolean, 3940 rounded: Boolean, 3941 stream: Boolean, 3942 striped: Boolean, 3943 value: { 3944 type: [Number, String], 3945 default: 0 3946 } 3947 }, 3948 data() { 3949 return { 3950 internalLazyValue: this.value || 0, 3951 isVisible: true 3952 }; 3953 }, 3954 computed: { 3955 __cachedBackground() { 3956 return this.$createElement('div', this.setBackgroundColor(this.backgroundColor || this.color, { 3957 staticClass: 'v-progress-linear__background', 3958 style: this.backgroundStyle 3959 })); 3960 }, 3961 __cachedBar() { 3962 return this.$createElement(this.computedTransition, [this.__cachedBarType]); 3963 }, 3964 __cachedBarType() { 3965 return this.indeterminate ? this.__cachedIndeterminate : this.__cachedDeterminate; 3966 }, 3967 __cachedBuffer() { 3968 return this.$createElement('div', { 3969 staticClass: 'v-progress-linear__buffer', 3970 style: this.styles 3971 }); 3972 }, 3973 __cachedDeterminate() { 3974 return this.$createElement('div', this.setBackgroundColor(this.color, { 3975 staticClass: `v-progress-linear__determinate`, 3976 style: { 3977 width: (0,helpers/* convertToUnit */.kb)(this.normalizedValue, '%') 3978 } 3979 })); 3980 }, 3981 __cachedIndeterminate() { 3982 return this.$createElement('div', { 3983 staticClass: 'v-progress-linear__indeterminate', 3984 class: { 3985 'v-progress-linear__indeterminate--active': this.active 3986 } 3987 }, [this.genProgressBar('long'), this.genProgressBar('short')]); 3988 }, 3989 __cachedStream() { 3990 if (!this.stream) return null; 3991 return this.$createElement('div', this.setTextColor(this.color, { 3992 staticClass: 'v-progress-linear__stream', 3993 style: { 3994 width: (0,helpers/* convertToUnit */.kb)(100 - this.normalizedBuffer, '%') 3995 } 3996 })); 3997 }, 3998 backgroundStyle() { 3999 const backgroundOpacity = this.backgroundOpacity == null ? this.backgroundColor ? 1 : 0.3 : parseFloat(this.backgroundOpacity); 4000 return { 4001 opacity: backgroundOpacity, 4002 [this.isReversed ? 'right' : 'left']: (0,helpers/* convertToUnit */.kb)(this.normalizedValue, '%'), 4003 width: (0,helpers/* convertToUnit */.kb)(Math.max(0, this.normalizedBuffer - this.normalizedValue), '%') 4004 }; 4005 }, 4006 classes() { 4007 return _objectSpread({ 4008 'v-progress-linear--absolute': this.absolute, 4009 'v-progress-linear--fixed': this.fixed, 4010 'v-progress-linear--query': this.query, 4011 'v-progress-linear--reactive': this.reactive, 4012 'v-progress-linear--reverse': this.isReversed, 4013 'v-progress-linear--rounded': this.rounded, 4014 'v-progress-linear--striped': this.striped, 4015 'v-progress-linear--visible': this.isVisible 4016 }, this.themeClasses); 4017 }, 4018 computedTransition() { 4019 return this.indeterminate ? transitions/* VFadeTransition */.Z5 : transitions/* VSlideXTransition */.Qn; 4020 }, 4021 isReversed() { 4022 return this.$vuetify.rtl !== this.reverse; 4023 }, 4024 normalizedBuffer() { 4025 return this.normalize(this.bufferValue); 4026 }, 4027 normalizedValue() { 4028 return this.normalize(this.internalLazyValue); 4029 }, 4030 reactive() { 4031 return Boolean(this.$listeners.change); 4032 }, 4033 styles() { 4034 const styles = {}; 4035 if (!this.active) { 4036 styles.height = 0; 4037 } 4038 if (!this.indeterminate && parseFloat(this.normalizedBuffer) !== 100) { 4039 styles.width = (0,helpers/* convertToUnit */.kb)(this.normalizedBuffer, '%'); 4040 } 4041 return styles; 4042 } 4043 }, 4044 methods: { 4045 genContent() { 4046 const slot = (0,helpers/* getSlot */.z9)(this, 'default', { 4047 value: this.internalLazyValue 4048 }); 4049 if (!slot) return null; 4050 return this.$createElement('div', { 4051 staticClass: 'v-progress-linear__content' 4052 }, slot); 4053 }, 4054 genListeners() { 4055 const listeners = this.$listeners; 4056 if (this.reactive) { 4057 listeners.click = this.onClick; 4058 } 4059 return listeners; 4060 }, 4061 genProgressBar(name) {
4062 return this.$createElement('div', this.setBackgroundColor(this.color, { 4063 staticClass: 'v-progress-linear__indeterminate', 4064 class: { 4065 [name]: true 4066 } 4067 })); 4068 }, 4069 onClick(e) { 4070 if (!this.reactive) return; 4071 const _this$$el$getBounding = this.$el.getBoundingClientRect(), 4072 width = _this$$el$getBounding.width; 4073 this.internalValue = e.offsetX / width * 100; 4074 }, 4075 onObserve(entries, observer, isIntersecting) { 4076 this.isVisible = isIntersecting; 4077 }, 4078 normalize(value) { 4079 if (value < 0) return 0; 4080 if (value > 100) return 100; 4081 return parseFloat(value); 4082 } 4083 }, 4084 render(h) { 4085 const data = { 4086 staticClass: 'v-progress-linear', 4087 attrs: { 4088 role: 'progressbar', 4089 'aria-valuemin': 0, 4090 'aria-valuemax': this.normalizedBuffer, 4091 'aria-valuenow': this.indeterminate ? undefined : this.normalizedValue 4092 }, 4093 class: this.classes, 4094 directives: [{ 4095 name: 'intersect', 4096 value: this.onObserve 4097 }], 4098 style: { 4099 bottom: this.bottom ? 0 : undefined, 4100 height: this.active ? (0,helpers/* convertToUnit */.kb)(this.height) : 0, 4101 top: this.top ? 0 : undefined 4102 }, 4103 on: this.genListeners() 4104 }; 4105 return h('div', data, [this.__cachedStream, this.__cachedBackground, this.__cachedBuffer, this.__cachedBar, this.genContent()]); 4106 } 4107})); 4108 4109/***/ }), 4110 4111/***/ 1685: 4112/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4113 4114"use strict"; 4115 4116// EXPORTS 4117__webpack_require__.d(__webpack_exports__, { 4118 Z: function() { return /* binding */ VSheet; } 4119}); 4120 4121// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 4122var web_dom_iterable = __webpack_require__(1181); 4123// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 4124var defineProperty = __webpack_require__(1180); 4125;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VSheet/VSheet.sass 4126// extracted by mini-css-extract-plugin 4127 4128// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/binds-attrs/index.js 4129var binds_attrs = __webpack_require__(1679); 4130// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 4131var colorable = __webpack_require__(8390); 4132// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/elevatable/index.js 4133var elevatable = __webpack_require__(3657); 4134// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/measurable/index.js 4135var measurable = __webpack_require__(8888); 4136// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/roundable/index.js 4137var roundable = __webpack_require__(4941); 4138// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 4139var themeable = __webpack_require__(7416); 4140// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 4141var mixins = __webpack_require__(9547); 4142;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VSheet/VSheet.js 4143 4144 4145function 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; } 4146function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 4147// Styles 4148 // Mixins 4149 4150 4151 4152 4153 4154 4155 // Helpers 4156 4157 4158/* @vue/component */ 4159 4160/* harmony default export */ var VSheet = ((0,mixins/* default */.Z)(binds_attrs/* default */.Z, colorable/* default */.Z, elevatable/* default */.Z, measurable/* default */.Z, roundable/* default */.Z, themeable/* default */.Z).extend({ 4161 name: 'v-sheet', 4162 props: { 4163 outlined: Boolean, 4164 shaped: Boolean, 4165 tag: { 4166 type: String, 4167 default: 'div' 4168 } 4169 }, 4170 computed: { 4171 classes() { 4172 return _objectSpread(_objectSpread(_objectSpread({ 4173 'v-sheet': true, 4174 'v-sheet--outlined': this.outlined, 4175 'v-sheet--shaped': this.shaped 4176 }, this.themeClasses), this.elevationClasses), this.roundedClasse
4176s); 4177 }, 4178 styles() { 4179 return this.measurableStyles; 4180 } 4181 }, 4182 render(h) { 4183 const data = { 4184 class: this.classes, 4185 style: this.styles, 4186 on: this.listeners$ 4187 }; 4188 return h(this.tag, this.setBackgroundColor(this.color, data), this.$slots.default); 4189 } 4190})); 4191 4192/***/ }), 4193 4194/***/ 3555: 4195/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4196 4197"use strict"; 4198/* harmony import */ var _VSheet__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1685); 4199 4200 4201/* harmony default export */ __webpack_exports__.Z = (_VSheet__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z); 4202 4203/***/ }), 4204 4205/***/ 1842: 4206/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4207 4208"use strict"; 4209 4210// EXPORTS 4211__webpack_require__.d(__webpack_exports__, { 4212 Z: function() { return /* binding */ VSnackbar; } 4213}); 4214 4215;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VSnackbar/VSnackbar.sass 4216// extracted by mini-css-extract-plugin 4217 4218// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/VSheet.js + 1 modules 4219var VSheet = __webpack_require__(1685); 4220// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 4221var colorable = __webpack_require__(8390); 4222// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 4223var themeable = __webpack_require__(7416); 4224// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/toggleable/index.js 4225var toggleable = __webpack_require__(1796); 4226// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/positionable/index.js 4227var positionable = __webpack_require__(4287); 4228// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 4229var mixins = __webpack_require__(9547); 4230// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 4231var helpers = __webpack_require__(6539); 4232// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 4233var console = __webpack_require__(9206); 4234;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VSnackbar/VSnackbar.js 4235// Styles 4236 // Components 4237 4238 // Mixins 4239 4240 4241 4242 4243 // Utilities 4244 4245 4246 4247 4248/* harmony default export */ var VSnackbar = ((0,mixins/* default */.Z)(VSheet/* default */.Z, colorable/* default */.Z, toggleable/* default */.Z, (0,positionable/* factory */.d)(['absolute', 'bottom', 'left', 'right', 'top']) 4249/* @vue/component */).extend({ 4250 name: 'v-snackbar', 4251 props: { 4252 app: Boolean, 4253 centered: Boolean, 4254 contentClass: { 4255 type: String, 4256 default: '' 4257 }, 4258 multiLine: Boolean, 4259 text: Boolean, 4260 timeout: { 4261 type: [Number, String], 4262 default: 5000 4263 }, 4264 transition: { 4265 type: [Boolean, String], 4266 default: 'v-snack-transition', 4267 validator: v => typeof v === 'string' || v === false 4268 }, 4269 vertical: Boolean 4270 }, 4271 data: () => ({ 4272 activeTimeout: -1 4273 }), 4274 computed: { 4275 classes() { 4276 return { 4277 'v-snack--absolute': this.absolute, 4278 'v-snack--active': this.isActive, 4279 'v-snack--bottom': this.bottom || !this.top, 4280 'v-snack--centered': this.centered, 4281 'v-snack--has-background': this.hasBackground, 4282 'v-snack--left': this.left, 4283 'v-snack--multi-line': this.multiLine && !this.vertical, 4284 'v-snack--right': this.right, 4285 'v-snack--text': this.text, 4286 'v-snack--top': this.top, 4287 'v-snack--vertical': this.vertical 4288 }; 4289 }, 4290 // Text and outlined styles both 4291 // use transparent backgrounds 4292 hasBackground() { 4293 return !this.text && !this.outlined; 4294 }, 4295 // Snackbar is dark by default 4296 // override themeable logic. 4297 isDark() { 4298 return this.hasBackground ? !this.light : themeable/* default */.Z.options.computed.isDark.call(this); 4299 }, 4300 styles() { 4301 if (this.absolute || !this.app) return {}; 4302 const _this$$vuetify$applic = this.$vuetify.application, 4303 bar = _this$$vuetify$applic.bar, 4304 bottom = _this$$vuetify$applic.bottom, 4305 footer = _this$$vuetify$applic.footer, 4306 insetFooter = _this$$vuetify$applic.insetFooter, 4307 left = _this$$vuetify$applic.left, 4308 right = _this$$vuetify$applic.right, 4309 top = _this$$vuetify$applic.top; 4310 return { 4311 paddingBottom: (0,helpers/* convertToUnit */.kb)(bottom + footer + insetFooter), 4312 paddingLeft: (0,helpers/* convertToUnit */.kb)(left), 4313 paddingRight: (0,helpers/* convertToUnit */.kb)(right), 4314 paddingTop: (0,helpers/* convertToUnit */.kb)(bar + top) 4315 }; 4316 } 4317 }, 4318 watch: { 4319 isActive: 'setTimeout', 4320 timeout: 'setTimeout' 4321 }, 4322 mounted() { 4323 if (this.isActive) this.setTimeout(); 4324 }, 4325 created() { 4326 /* istanbul ignore next */ 4327 if (this.$attrs.hasOwnProperty('auto-height')) { 4328 (0,console/* removed */.Jk)('auto-height', this); 4329 } 4330 /* istanbul ignore next */ 4331 // eslint-disable-next-line eqeqeq 4332 4333 if (this.timeout == 0) { 4334 (0,console/* deprecate */.Rn)('timeout="0"', '-1', this); 4335 } 4336 }, 4337 methods: { 4338 genActions() { 4339 return this.$createElement('div', { 4340 staticClass: 'v-snack__action ' 4341 }, [(0,helpers/* getSlot */.z9)(this, 'action', { 4342 attrs: { 4343 class: 'v-snack__btn' 4344 } 4345 })]); 4346 }, 4347 genContent() { 4348 return this.$createElement('div', { 4349 staticClass: 'v-snack__content', 4350 class: { 4351 [this.contentClass]: true 4352 }, 4353 attrs: { 4354 role: 'status', 4355 'aria-live': 'polite' 4356 } 4357 }, [(0,helpers/* getSlot */.z9)(this)]); 4358 }, 4359 genWrapper() {
4360 const setColor = this.hasBackground ? this.setBackgroundColor : this.setTextColor; 4361 const data = setColor(this.color, { 4362 staticClass: 'v-snack__wrapper', 4363 class: VSheet/* default */.Z.options.computed.classes.call(this), 4364 style: VSheet/* default */.Z.options.computed.styles.call(this), 4365 directives: [{ 4366 name: 'show', 4367 value: this.isActive 4368 }], 4369 on: { 4370 pointerenter: () => window.clearTimeout(this.activeTimeout), 4371 pointerleave: this.setTimeout 4372 } 4373 }); 4374 return this.$createElement('div', data, [this.genContent(), this.genActions()]); 4375 }, 4376 genTransition() { 4377 return this.$createElement('transition', { 4378 props: { 4379 name: this.transition 4380 } 4381 }, [this.genWrapper()]); 4382 }, 4383 setTimeout() { 4384 window.clearTimeout(this.activeTimeout); 4385 const timeout = Number(this.timeout); 4386 if (!this.isActive || 4387 // TODO: remove 0 in v3 4388 [0, -1].includes(timeout)) { 4389 return; 4390 } 4391 this.activeTimeout = window.setTimeout(() => { 4392 this.isActive = false; 4393 }, timeout); 4394 } 4395 }, 4396 render(h) { 4397 return h('div', { 4398 staticClass: 'v-snack', 4399 class: this.classes, 4400 style: this.styles 4401 }, [this.transition !== false ? this.genTransition() : this.genWrapper()]); 4402 } 4403})); 4404 4405/***/ }), 4406 4407/***/ 1850: 4408/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4409 4410"use strict"; 4411 4412// EXPORTS 4413__webpack_require__.d(__webpack_exports__, { 4414 Z: function() { return /* binding */ VStepper; } 4415}); 4416 4417// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 4418var web_dom_iterable = __webpack_require__(1181); 4419// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 4420var defineProperty = __webpack_require__(1180); 4421;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VStepper/VStepper.sass 4422// extracted by mini-css-extract-plugin 4423 4424// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/index.js 4425var VSheet = __webpack_require__(3555); 4426// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/registrable/index.js 4427var registrable = __webpack_require__(474); 4428// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/proxyable/index.js 4429var proxyable = __webpack_require__(8747); 4430// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 4431var mixins = __webpack_require__(9547); 4432// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 4433var console = __webpack_require__(9206); 4434;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VStepper/VStepper.js 4435 4436 4437function 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; } 4438function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 4439// Styles 4440 // Extensions 4441 4442 // Mixins 4443 4444 4445 // Utilities 4446 4447 4448 4449const baseMixins = (0,mixins/* default */.Z)(VSheet/* default */.Z, (0,registrable/* provide */.J)('stepper'), proxyable/* default */.Z); 4450/* @vue/component */ 4451 4452/* harmony default export */ var VStepper = (baseMixins.extend({ 4453 name: 'v-stepper', 4454 provide() { 4455 return { 4456 stepClick: this.stepClick, 4457 isVertical: this.vertical 4458 }; 4459 }, 4460 props: { 4461 altLabels: Boolean, 4462 nonLinear: Boolean, 4463 flat: Boolean, 4464 vertical: Boolean 4465 }, 4466 data() { 4467 const data = { 4468 isBooted: false, 4469 steps: [], 4470 content: [], 4471 isReverse: false 4472 }; 4473 data.internalLazyValue = this.value != null ? this.value : (data[0] || {}).step || 1; 4474 return data; 4475 }, 4476 computed: { 4477 classes() { 4478 return _objectSpread({ 4479 'v-stepper--flat': this.flat, 4480 'v-stepper--is-booted': this.isBooted, 4481 'v-stepper--vertical': this.vertical, 4482 'v-stepper--alt-labels': this.altLabels, 4483 'v-stepper--non-linear': this.nonLinear 4484 }, VSheet/* default */.Z.options.computed.classes.call(this)); 4485 }, 4486 styles() { 4487 return _objectSpread({}, VSheet/* default */.Z.options.computed.styles.call(this)); 4488 } 4489 }, 4490 watch: { 4491 internalValue(val, oldVal) { 4492 this.isReverse = Number(val) < Number(oldVal); 4493 oldVal && (this.isBooted = true); 4494 this.updateView(); 4495 } 4496 }, 4497 created() { 4498 /* istanbul ignore next */ 4499 if (this.$listeners.input) { 4500 (0,console/* breaking */.fK)('@input', '@change', this); 4501 } 4502 }, 4503 mounted() { 4504 this.updateView(); 4505 }, 4506 methods: { 4507 register(item) { 4508 if (item.$options.name === 'v-stepper-step') { 4509 this.steps.push(item); 4510 } else if (item.$options.name === 'v-stepper-content') { 4511 item.isVertical = this.vertical; 4512 this.content.push(item); 4513 } 4514 }, 4515 unregister(item) { 4516 if (item.$options.name === 'v-stepper-step') { 4517 this.steps = this.steps.filter(i => i !== item); 4518 } else if (item.$options.name === 'v-stepper-content') { 4519 item.isVertical = this.vertical; 4520 this.content = this.content.filter(i => i !== item); 4521 } 4522 }, 4523 stepClick(step) { 4524 this.$nextTick(() => this.internalValue = step); 4525 }, 4526 updateView() { 4527 for (let index = this.steps.length; --index >= 0;) { 4528 this.steps[index].toggle(this.internalValue); 4529 } 4530 for (let index = this.content.length; --index >= 0;) { 4531 this.content[index].toggle(this.internalValue, this.isReverse); 4532 } 4533 } 4534 }, 4535 render(h) { 4536 return h(this.tag, { 4537 staticClass: 'v-stepper', 4538 class: this.classes, 4539 style: this.styles 4540 }, this.$slots.default); 4541 } 4542})); 4543 4544/***/ }), 4545 4546/***/ 7478: 4547/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4548 4549"use strict"; 4550/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6108); 4551/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__); 4552/* harmony import */ var _transitions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5712); 4553/* harmony import */ var _mixins_registrable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(474); 4554/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 4555/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9547); 4556 4557// Components 4558 // Mixins 4559 4560 // Helpers 4561 4562 // Utilities 4563 4564 4565const baseMixins = (0,_util_mixins__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)((0,_mixins_registrable__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f)('stepper', 'v-stepper-content', 'v-stepper')); 4566/* @vue/component */ 4567 4568/* harmony default export */ __webpack_exports__.Z = (baseMixins.extend().extend({ 4569 name: 'v-stepper-content', 4570 inject: { 4571 isVerticalProvided: { 4572 from: 'isVertical' 4573 } 4574 }, 4575 props: { 4576 step: { 4577 type: [Number, String], 4578 required: true 4579 } 4580 }, 4581 data() { 4582 return { 4583 height: 0, 4584 // Must be null to allow 4585 // previous comparison 4586 isActive: null, 4587 isReverse: false, 4588 isVertical: this.isVerticalProvided 4589 }; 4590 }, 4591 computed: { 4592 computedTransition() { 4593 // Fix for #8978 4594 const reverse = this.$vuetify.rtl ? !this.isReverse : this.isReverse;
4595 return reverse ? _transitions__WEBPACK_IMPORTED_MODULE_3__/* .VTabReverseTransition */ .YV : _transitions__WEBPACK_IMPORTED_MODULE_3__/* .VTabTransition */ .n6; 4596 }, 4597 styles() { 4598 if (!this.isVertical) return {}; 4599 return { 4600 height: (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .convertToUnit */ .kb)(this.height) 4601 }; 4602 } 4603 }, 4604 watch: { 4605 isActive(current, previous) { 4606 // If active and the previous state 4607 // was null, is just booting up 4608 if (current && previous == null) { 4609 this.height = 'auto'; 4610 return; 4611 } 4612 if (!this.isVertical) return; 4613 if (this.isActive) this.enter();else this.leave(); 4614 } 4615 }, 4616 mounted() { 4617 this.$refs.wrapper.addEventListener('transitionend', this.onTransition, false); 4618 this.stepper && this.stepper.register(this); 4619 }, 4620 beforeDestroy() { 4621 this.$refs.wrapper.removeEventListener('transitionend', this.onTransition, false); 4622 this.stepper && this.stepper.unregister(this); 4623 }, 4624 methods: { 4625 onTransition(e) { 4626 if (!this.isActive || e.propertyName !== 'height') return; 4627 this.height = 'auto'; 4628 }, 4629 enter() { 4630 let scrollHeight = 0; // Render bug with height 4631 4632 requestAnimationFrame(() => { 4633 scrollHeight = this.$refs.wrapper.scrollHeight; 4634 }); 4635 this.height = 0; // Give the collapsing element time to collapse 4636 4637 setTimeout(() => this.isActive && (this.height = scrollHeight || 'auto'), 450); 4638 }, 4639 leave() { 4640 this.height = this.$refs.wrapper.clientHeight; 4641 setTimeout(() => this.height = 0, 10); 4642 }, 4643 toggle(step, reverse) { 4644 this.isActive = step.toString() === this.step.toString(); 4645 this.isReverse = reverse; 4646 } 4647 }, 4648 render(h) { 4649 const contentData = { 4650 staticClass: 'v-stepper__content' 4651 }; 4652 const wrapperData = { 4653 staticClass: 'v-stepper__wrapper', 4654 style: this.styles, 4655 ref: 'wrapper' 4656 }; 4657 if (!this.isVertical) { 4658 contentData.directives = [{ 4659 name: 'show', 4660 value: this.isActive 4661 }]; 4662 } 4663 const wrapper = h('div', wrapperData, [this.$slots.default]); 4664 const content = h('div', contentData, [wrapper]); 4665 return h(this.computedTransition, { 4666 on: this.$listeners 4667 }, [content]); 4668 } 4669})); 4670 4671/***/ }), 4672 4673/***/ 5827: 4674/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4675 4676"use strict"; 4677/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6108); 4678/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__); 4679/* harmony import */ var _VIcon__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9548); 4680/* harmony import */ var _mixins_colorable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8390); 4681/* harmony import */ var _mixins_registrable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(474); 4682/* harmony import */ var _directives_ripple__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4261); 4683/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9547); 4684/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6539); 4685 4686// Components 4687 // Mixins 4688 4689 4690 // Directives 4691 4692 // Utilities 4693 4694 4695 4696const baseMixins = (0,_util_mixins__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_mixins_colorable__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z, (0,_mixins_registrable__WEBPACK_IMPORTED_MODULE_3__/* .inject */ .f)('stepper', 'v-stepper-step', 'v-stepper')); 4697/* @vue/component */ 4698 4699/* harmony default export */ __webpack_exports__.Z = (baseMixins.extend().extend({ 4700 name: 'v-stepper-step', 4701 directives: { 4702 ripple: _directives_ripple__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z 4703 }, 4704 inject: ['stepClick'], 4705 props: { 4706 color: { 4707 type: String, 4708 default: 'primary' 4709 }, 4710 complete: Boolean, 4711 completeIcon: { 4712 type: String, 4713 default: '$complete' 4714 }, 4715 editable: Boolean, 4716 editIcon: { 4717 type: String, 4718 default: '$edit' 4719 }, 4720 errorIcon: { 4721 type: String, 4722 default: '$error' 4723 }, 4724 rules: { 4725 type: Array, 4726 default: () => [] 4727 }, 4728 step: [Number, String] 4729 }, 4730 data() { 4731 return { 4732 isActive: false, 4733 isInactive: true 4734 }; 4735 }, 4736 computed: { 4737 classes() { 4738 return { 4739 'v-stepper__step--active': this.isActive, 4740 'v-stepper__step--editable': this.editable, 4741 'v-stepper__step--inactive': this.isInactive, 4742 'v-stepper__step--error error--text': this.hasError, 4743 'v-stepper__step--complete': this.complete 4744 }; 4745 }, 4746 hasError() { 4747 return this.rules.some(validate => validate() !== true); 4748 } 4749 }, 4750 mounted() { 4751 this.stepper && this.stepper.register(this); 4752 }, 4753 beforeDestroy() { 4754 this.stepper && this.stepper.unregister(this); 4755 }, 4756 methods: { 4757 click(e) { 4758 e.stopPropagation(); 4759 this.$emit('click', e); 4760 if (this.editable) { 4761 this.stepClick(this.step); 4762 } 4763 }, 4764 genIcon(icon) { 4765 return this.$createElement(_VIcon__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z, icon); 4766 }, 4767 genLabel() { 4768 return this.$createElement('div', { 4769 staticClass: 'v-stepper__label' 4770 }, this.$slots.default); 4771 }, 4772 genStep() { 4773 const color = !this.hasError && (this.complete || this.isActive) ? this.color : false;
4774 return this.$createElement('span', this.setBackgroundColor(color, { 4775 staticClass: 'v-stepper__step__step' 4776 }), this.genStepContent()); 4777 }, 4778 genStepContent() { 4779 const children = []; 4780 if (this.hasError) { 4781 children.push(this.genIcon(this.errorIcon)); 4782 } else if (this.complete) { 4783 if (this.editable) { 4784 children.push(this.genIcon(this.editIcon)); 4785 } else { 4786 children.push(this.genIcon(this.completeIcon)); 4787 } 4788 } else { 4789 children.push(String(this.step)); 4790 } 4791 return children; 4792 }, 4793 keyboardClick(e) { 4794 if (e.keyCode === _util_helpers__WEBPACK_IMPORTED_MODULE_6__/* .keyCodes */ .Do.space) { 4795 this.click(e); 4796 } 4797 }, 4798 toggle(step) { 4799 this.isActive = step.toString() === this.step.toString(); 4800 this.isInactive = Number(step) < Number(this.step); 4801 } 4802 }, 4803 render(h) { 4804 return h('div', { 4805 attrs: { 4806 tabindex: this.editable ? 0 : -1 4807 }, 4808 staticClass: 'v-stepper__step', 4809 class: this.classes, 4810 directives: [{ 4811 name: 'ripple', 4812 value: this.editable 4813 }], 4814 on: { 4815 click: this.click, 4816 keydown: this.keyboardClick 4817 } 4818 }, [this.genStep(), this.genLabel()]); 4819 } 4820})); 4821 4822/***/ }), 4823 4824/***/ 849: 4825/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 4826 4827"use strict"; 4828 4829// EXPORTS 4830__webpack_require__.d(__webpack_exports__, { 4831 Z: function() { return /* binding */ VTextField_VTextField; } 4832}); 4833 4834// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 4835var web_dom_iterable = __webpack_require__(1181); 4836// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.object.is.js 4837var es6_object_is = __webpack_require__(9176); 4838// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules 4839var objectWithoutProperties = __webpack_require__(91); 4840// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.regexp.to-string.js 4841var es6_regexp_to_string = __webpack_require__(6108); 4842// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 4843var defineProperty = __webpack_require__(1180); 4844// EXTERNAL MODULE: ./node_modules/vuetify/src/components/VTextField/VTextField.sass 4845var VTextField = __webpack_require__(8025); 4846// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VInput/index.js + 5 modules 4847var VInput = __webpack_require__(1591); 4848;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VCounter/VCounter.sass 4849// extracted by mini-css-extract-plugin 4850 4851// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/themeable/index.js 4852var themeable = __webpack_require__(7416); 4853// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 4854var mixins = __webpack_require__(9547); 4855;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VCounter/VCounter.js 4856 4857 4858function 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; } 4859function _objectSpread(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) { (0,defineProperty/* default */.Z)(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; } 4860// Styles 4861 // Mixins 4862 4863 4864 4865/* @vue/component */ 4866 4867/* harmony default export */ var VCounter = ((0,mixins/* default */.Z)(themeable/* default */.Z).extend({ 4868 name: 'v-counter', 4869 functional: true, 4870 props: { 4871 value: { 4872 type: [Number, String], 4873 default: '' 4874 }, 4875 max: [Number, String] 4876 }, 4877 render(h, ctx) { 4878 const props = ctx.props; 4879 const max = parseInt(props.max, 10); 4880 const value = parseInt(props.value, 10); 4881 const content = max ? `${value} / ${max}` : String(props.value); 4882 const isGreater = max && value > max; 4883 return h('div', { 4884 staticClass: 'v-counter', 4885 class: _objectSpread({ 4886 'error--text': isGreater 4887 }, (0,themeable/* functionalThemeClasses */.X)(ctx)) 4888 }, content); 4889 } 4890})); 4891;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VCounter/index.js 4892 4893 4894/* harmony default export */ var components_VCounter = (VCounter); 4895// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VLabel/index.js + 2 modules 4896var VLabel = __webpack_require__(8877); 4897// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/intersect/index.js 4898var intersect = __webpack_require__(9106); 4899// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 4900var console = __webpack_require__(9206); 4901// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 4902var vue_esm = __webpack_require__(538); 4903;// CONCATENATED MODULE: ./node_modules/vuetify/lib/mixins/intersectable/index.js 4904// Directives 4905 // Utilities 4906 4907 // Types 4908 4909 4910function intersectable(options) { 4911 return vue_esm/* default */.ZP.extend({ 4912 name: 'intersectable', 4913 data: () => ({ 4914 isIntersecting: false 4915 }), 4916 mounted() { 4917 intersect/* default */.Z.inserted(this.$el, { 4918 name: 'intersect', 4919 value: this.onObserve 4920 }, this.$vnode); 4921 }, 4922 destroyed() { 4923 intersect/* default */.Z.unbind(this.$el, { 4924 name: 'intersect', 4925 value: this.onObserve 4926 }, this.$vnode); 4927 }, 4928 methods: { 4929 onObserve(entries, observer, isIntersecting) { 4930 this.isIntersecting = isIntersecting; 4931 if (!isIntersecting) return; 4932 for (let i = 0, length = options.onVisible.length; i < length; i++) { 4933 const callback = this[options.onVisible[i]]; 4934 if (typeof callback === 'function') { 4935 callback(); 4936 continue; 4937 }
4938 (0,console/* consoleWarn */.Kd)(options.onVisible[i] + ' method is not available on the instance but referenced in intersectable mixin options'); 4939 } 4940 } 4941 } 4942 }); 4943} 4944// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/loadable/index.js + 1 modules 4945var loadable = __webpack_require__(5419); 4946// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/validatable/index.js 4947var validatable = __webpack_require__(7123); 4948// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/resize/index.js 4949var resize = __webpack_require__(6797); 4950// EXTERNAL MODULE: ./node_modules/vuetify/lib/directives/ripple/index.js + 1 modules 4951var ripple = __webpack_require__(4261); 4952// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/dom.js 4953var dom = __webpack_require__(8616); 4954// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 4955var helpers = __webpack_require__(6539); 4956;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VTextField/VTextField.js 4957 4958 4959 4960 4961 4962const _excluded = ["title"]; 4963function VTextField_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; } 4964function VTextField_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? VTextField_ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : VTextField_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 4965// Styles 4966 // Extensions 4967 4968 // Components 4969 4970 4971 // Mixins 4972 4973 4974 4975 // Directives 4976 4977 4978 // Utilities 4979 4980 4981 4982 // Types 4983 4984 4985const baseMixins = (0,mixins/* default */.Z)(VInput/* default */.Z, intersectable({ 4986 onVisible: ['onResize', 'tryAutofocus'] 4987}), loadable/* default */.Z); 4988const dirtyTypes = ['color', 'file', 'time', 'date', 'datetime-local', 'week', 'month']; 4989/* @vue/component */ 4990 4991/* harmony default export */ var VTextField_VTextField = (baseMixins.extend().extend({ 4992 name: 'v-text-field', 4993 directives: { 4994 resize: resize/* default */.Z, 4995 ripple: ripple/* default */.Z 4996 }, 4997 inheritAttrs: false, 4998 props: { 4999 appendOuterIcon: String, 5000 autofocus: Boolean, 5001 clearable: Boolean, 5002 clearIcon: { 5003 type: String, 5004 default: '$clear' 5005 }, 5006 counter: [Boolean, Number, String], 5007 counterValue: Function, 5008 filled: Boolean, 5009 flat: Boolean, 5010 fullWidth: Boolean, 5011 label: String, 5012 outlined: Boolean, 5013 placeholder: String, 5014 prefix: String, 5015 prependInnerIcon: String, 5016 persistentPlaceholder: Boolean, 5017 reverse: Boolean, 5018 rounded: Boolean, 5019 shaped: Boolean, 5020 singleLine: Boolean, 5021 solo: Boolean, 5022 soloInverted: Boolean, 5023 suffix: String, 5024 type: { 5025 type: String, 5026 default: 'text' 5027 } 5028 }, 5029 data: () => ({ 5030 badInput: false, 5031 labelWidth: 0, 5032 prefixWidth: 0, 5033 prependWidth: 0, 5034 initialValue: null, 5035 isBooted: false, 5036 isClearing: false 5037 }), 5038 computed: { 5039 classes() { 5040 return VTextField_objectSpread(VTextField_objectSpread({}, VInput/* default */.Z.options.computed.classes.call(this)), {}, { 5041 'v-text-field': true, 5042 'v-text-field--full-width': this.fullWidth, 5043 'v-text-field--prefix': this.prefix, 5044 'v-text-field--single-line': this.isSingle, 5045 'v-text-field--solo': this.isSolo, 5046 'v-text-field--solo-inverted': this.soloInverted, 5047 'v-text-field--solo-flat': this.flat, 5048 'v-text-field--filled': this.filled, 5049 'v-text-field--is-booted': this.isBooted, 5050 'v-text-field--enclosed': this.isEnclosed, 5051 'v-text-field--reverse': this.reverse, 5052 'v-text-field--outlined': this.outlined, 5053 'v-text-field--placeholder': this.placeholder, 5054 'v-text-field--rounded': this.rounded, 5055 'v-text-field--shaped': this.shaped 5056 }); 5057 }, 5058 computedColor() { 5059 const computedColor = validatable/* default */.Z.options.computed.computedColor.call(this); 5060 if (!this.soloInverted || !this.isFocused) return computedColor; 5061 return this.color || 'primary'; 5062 }, 5063 computedCounterValue() { 5064 if (typeof this.counterValue === 'function') { 5065 return this.counterValue(this.internalValue); 5066 } 5067 return [...(this.internalValue || '').toString()].length; 5068 }, 5069 hasCounter() { 5070 return this.counter !== false && this.counter != null; 5071 },
5072 hasDetails() { 5073 return VInput/* default */.Z.options.computed.hasDetails.call(this) || this.hasCounter; 5074 }, 5075 internalValue: { 5076 get() { 5077 return this.lazyValue; 5078 }, 5079 set(val) { 5080 this.lazyValue = val; 5081 this.$emit('input', this.lazyValue); 5082 } 5083 }, 5084 isDirty() { 5085 var _a; 5086 return ((_a = this.lazyValue) === null || _a === void 0 ? void 0 : _a.toString().length) > 0 || this.badInput; 5087 }, 5088 isEnclosed() { 5089 return this.filled || this.isSolo || this.outlined; 5090 }, 5091 isLabelActive() { 5092 return this.isDirty || dirtyTypes.includes(this.type); 5093 }, 5094 isSingle() { 5095 return this.isSolo || this.singleLine || this.fullWidth || 5096 // https://material.io/components/text-fields/#filled-text-field 5097 this.filled && !this.hasLabel; 5098 }, 5099 isSolo() { 5100 return this.solo || this.soloInverted; 5101 }, 5102 labelPosition() { 5103 let offset = this.prefix && !this.labelValue ? this.prefixWidth : 0; 5104 if (this.labelValue && this.prependWidth) offset -= this.prependWidth; 5105 return this.$vuetify.rtl === this.reverse ? { 5106 left: offset, 5107 right: 'auto' 5108 } : { 5109 left: 'auto', 5110 right: offset 5111 }; 5112 }, 5113 showLabel() { 5114 return this.hasLabel && !(this.isSingle && this.labelValue); 5115 }, 5116 labelValue() { 5117 return this.isFocused || this.isLabelActive || this.persistentPlaceholder; 5118 } 5119 }, 5120 watch: { 5121 // labelValue: 'setLabelWidth', // moved to mounted, see #11533 5122 outlined: 'setLabelWidth', 5123 label() { 5124 this.$nextTick(this.setLabelWidth); 5125 }, 5126 prefix() { 5127 this.$nextTick(this.setPrefixWidth); 5128 }, 5129 isFocused: 'updateValue', 5130 value(val) { 5131 this.lazyValue = val; 5132 } 5133 }, 5134 created() { 5135 /* istanbul ignore next */ 5136 if (this.$attrs.hasOwnProperty('box')) { 5137 (0,console/* breaking */.fK)('box', 'filled', this); 5138 } 5139 /* istanbul ignore next */ 5140 5141 if (this.$attrs.hasOwnProperty('browser-autocomplete')) { 5142 (0,console/* breaking */.fK)('browser-autocomplete', 'autocomplete', this); 5143 } 5144 /* istanbul ignore if */ 5145 5146 if (this.shaped && !(this.filled || this.outlined || this.isSolo)) { 5147 (0,console/* consoleWarn */.Kd)('shaped should be used with either filled or outlined', this); 5148 } 5149 }, 5150 mounted() { 5151 // #11533 5152 this.$watch(() => this.labelValue, this.setLabelWidth); 5153 this.autofocus && this.tryAutofocus(); 5154 requestAnimationFrame(() => { 5155 this.isBooted = true; 5156 requestAnimationFrame(() => { 5157 if (!this.isIntersecting) { 5158 this.onResize(); 5159 } 5160 }); 5161 }); 5162 }, 5163 methods: { 5164 /** @public */ 5165 focus() { 5166 this.onFocus(); 5167 }, 5168 /** @public */ 5169 blur(e) { 5170 // https://github.com/vuetifyjs/vuetify/issues/5913 5171 // Safari tab order gets broken if called synchronous 5172 window.requestAnimationFrame(() => { 5173 this.$refs.input && this.$refs.input.blur(); 5174 }); 5175 }, 5176 clearableCallback() { 5177 this.$refs.input && this.$refs.input.focus(); 5178 this.$nextTick(() => this.internalValue = null); 5179 }, 5180 genAppendSlot() { 5181 const slot = []; 5182 if (this.$slots['append-outer']) { 5183 slot.push(this.$slots['append-outer']); 5184 } else if (this.appendOuterIcon) { 5185 slot.push(this.genIcon('appendOuter')); 5186 } 5187 return this.genSlot('append', 'outer', slot); 5188 }, 5189 genPrependInnerSlot() { 5190 const slot = []; 5191 if (this.$slots['prepend-inner']) { 5192 slot.push(this.$slots['prepend-inner']); 5193 } else if (this.prependInnerIcon) { 5194 slot.push(this.genIcon('prependInner')); 5195 } 5196 return this.genSlot('prepend', 'inner', slot); 5197 }, 5198 genIconSlot() { 5199 const slot = []; 5200 if (this.$slots.append) { 5201 slot.push(this.$slots.append); 5202 } else if (this.appendIcon) { 5203 slot.push(this.genIcon('append')); 5204 } 5205 return this.genSlot('append', 'inner', slot); 5206 }, 5207 genInputSlot() { 5208 const input = VInput/* default */.Z.options.methods.genInputSlot.call(this);
5209 const prepend = this.genPrependInnerSlot(); 5210 if (prepend) { 5211 input.children = input.children || []; 5212 input.children.unshift(prepend); 5213 } 5214 return input; 5215 }, 5216 genClearIcon() { 5217 if (!this.clearable) return null; // if the text field has no content then don't display the clear icon. 5218 // We add an empty div because other controls depend on a ref to append inner 5219 5220 if (!this.isDirty) { 5221 return this.genSlot('append', 'inner', [this.$createElement('div')]); 5222 } 5223 return this.genSlot('append', 'inner', [this.genIcon('clear', this.clearableCallback)]); 5224 }, 5225 genCounter() { 5226 var _a, _b, _c; 5227 if (!this.hasCounter) return null; 5228 const max = this.counter === true ? this.attrs$.maxlength : this.counter; 5229 const props = { 5230 dark: this.dark, 5231 light: this.light, 5232 max, 5233 value: this.computedCounterValue 5234 }; 5235 return (_c = (_b = (_a = this.$scopedSlots).counter) === null || _b === void 0 ? void 0 : _b.call(_a, { 5236 props 5237 })) !== null && _c !== void 0 ? _c : this.$createElement(components_VCounter, { 5238 props 5239 }); 5240 }, 5241 genControl() { 5242 return VInput/* default */.Z.options.methods.genControl.call(this); 5243 }, 5244 genDefaultSlot() { 5245 return [this.genFieldset(), this.genTextFieldSlot(), this.genClearIcon(), this.genIconSlot(), this.genProgress()]; 5246 }, 5247 genFieldset() { 5248 if (!this.outlined) return null; 5249 return this.$createElement('fieldset', { 5250 attrs: { 5251 'aria-hidden': true 5252 } 5253 }, [this.genLegend()]); 5254 }, 5255 genLabel() { 5256 if (!this.showLabel) return null; 5257 const data = { 5258 props: { 5259 absolute: true, 5260 color: this.validationState, 5261 dark: this.dark, 5262 disabled: this.isDisabled, 5263 focused: !this.isSingle && (this.isFocused || !!this.validationState), 5264 for: this.computedId, 5265 left: this.labelPosition.left, 5266 light: this.light, 5267 right: this.labelPosition.right, 5268 value: this.labelValue 5269 } 5270 }; 5271 return this.$createElement(VLabel/* default */.Z, data, this.$slots.label || this.label); 5272 }, 5273 genLegend() { 5274 const width = !this.singleLine && (this.labelValue || this.isDirty) ? this.labelWidth : 0; 5275 const span = this.$createElement('span', { 5276 domProps: { 5277 innerHTML: '​' 5278 }, 5279 staticClass: 'notranslate' 5280 }); 5281 return this.$createElement('legend', { 5282 style: { 5283 width: !this.isSingle ? (0,helpers/* convertToUnit */.kb)(width) : undefined 5284 } 5285 }, [span]); 5286 }, 5287 genInput() { 5288 const listeners = Object.assign({}, this.listeners$); 5289 delete listeners.change; // Change should not be bound externally 5290 5291 const _this$attrs$ = this.attrs$, 5292 title = _this$attrs$.title, 5293 inputAttrs = (0,objectWithoutProperties/* default */.Z)(_this$attrs$, _excluded); 5294 return this.$createElement('input', { 5295 style: {}, 5296 domProps: { 5297 value: this.type === 'number' && Object.is(this.lazyValue, -0) ? '-0' : this.lazyValue 5298 }, 5299 attrs: VTextField_objectSpread(VTextField_objectSpread({}, inputAttrs), {}, { 5300 autofocus: this.autofocus, 5301 disabled: this.isDisabled, 5302 id: this.computedId, 5303 placeholder: this.persistentPlaceholder || this.isFocused || !this.hasLabel ? this.placeholder : undefined, 5304 readonly: this.isReadonly, 5305 type: this.type 5306 }), 5307 on: Object.assign(listeners, { 5308 blur: this.onBlur, 5309 input: this.onInput, 5310 focus: this.onFocus, 5311 keydown: this.onKeyDown 5312 }), 5313 ref: 'input', 5314 directives: [{ 5315 name: 'resize', 5316 modifiers: { 5317 quiet: true 5318 }, 5319 value: this.onResize 5320 }] 5321 }); 5322 }, 5323 genMessages() {
5324 if (!this.showDetails) return null; 5325 const messagesNode = VInput/* default */.Z.options.methods.genMessages.call(this); 5326 const counterNode = this.genCounter(); 5327 return this.$createElement('div', { 5328 staticClass: 'v-text-field__details' 5329 }, [messagesNode, counterNode]); 5330 }, 5331 genTextFieldSlot() { 5332 return this.$createElement('div', { 5333 staticClass: 'v-text-field__slot' 5334 }, [this.genLabel(), this.prefix ? this.genAffix('prefix') : null, this.genInput(), this.suffix ? this.genAffix('suffix') : null]); 5335 }, 5336 genAffix(type) { 5337 return this.$createElement('div', { 5338 class: `v-text-field__${type}`, 5339 ref: type 5340 }, this[type]); 5341 }, 5342 onBlur(e) { 5343 this.isFocused = false; 5344 e && this.$nextTick(() => this.$emit('blur', e)); 5345 }, 5346 onClick() { 5347 if (this.isFocused || this.isDisabled || !this.$refs.input) return; 5348 this.$refs.input.focus(); 5349 }, 5350 onFocus(e) { 5351 if (!this.$refs.input) return; 5352 const root = (0,dom/* attachedRoot */.e)(this.$el); 5353 if (!root) return; 5354 if (root.activeElement !== this.$refs.input) { 5355 return this.$refs.input.focus(); 5356 } 5357 if (!this.isFocused) { 5358 this.isFocused = true; 5359 e && this.$emit('focus', e); 5360 } 5361 }, 5362 onInput(e) { 5363 const target = e.target; 5364 this.internalValue = target.value; 5365 this.badInput = target.validity && target.validity.badInput; 5366 }, 5367 onKeyDown(e) { 5368 if (e.keyCode === helpers/* keyCodes */.Do.enter && this.lazyValue !== this.initialValue) { 5369 this.initialValue = this.lazyValue; 5370 this.$emit('change', this.initialValue); 5371 } 5372 this.$emit('keydown', e); 5373 }, 5374 onMouseDown(e) { 5375 // Prevent input from being blurred 5376 if (e.target !== this.$refs.input) { 5377 e.preventDefault(); 5378 e.stopPropagation(); 5379 } 5380 VInput/* default */.Z.options.methods.onMouseDown.call(this, e); 5381 }, 5382 onMouseUp(e) { 5383 if (this.hasMouseDown) this.focus(); 5384 VInput/* default */.Z.options.methods.onMouseUp.call(this, e); 5385 }, 5386 setLabelWidth() { 5387 if (!this.outlined) return; 5388 this.labelWidth = this.$refs.label ? Math.min(this.$refs.label.scrollWidth * 0.75 + 6, this.$el.offsetWidth - 24) : 0; 5389 }, 5390 setPrefixWidth() { 5391 if (!this.$refs.prefix) return; 5392 this.prefixWidth = this.$refs.prefix.offsetWidth; 5393 }, 5394 setPrependWidth() { 5395 if (!this.outlined || !this.$refs['prepend-inner']) return; 5396 this.prependWidth = this.$refs['prepend-inner'].offsetWidth; 5397 }, 5398 tryAutofocus() { 5399 if (!this.autofocus || typeof document === 'undefined' || !this.$refs.input) return false; 5400 const root = (0,dom/* attachedRoot */.e)(this.$el); 5401 if (!root || root.activeElement === this.$refs.input) return false; 5402 this.$refs.input.focus(); 5403 return true; 5404 }, 5405 updateValue(val) { 5406 // Sets validationState from validatable 5407 this.hasColor = val; 5408 if (val) { 5409 this.initialValue = this.lazyValue; 5410 } else if (this.initialValue !== this.lazyValue) { 5411 this.$emit('change', this.lazyValue); 5412 } 5413 }, 5414 onResize() { 5415 this.setLabelWidth(); 5416 this.setPrefixWidth(); 5417 this.setPrependWidth(); 5418 } 5419 } 5420})); 5421 5422/***/ }), 5423 5424/***/ 7981: 5425/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5426 5427"use strict"; 5428/* harmony import */ var _mixins_themeable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7416); 5429// Mixins 5430 5431/* @vue/component */ 5432 5433/* harmony default export */ __webpack_exports__.Z = (_mixins_themeable__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend({ 5434 name: 'v-theme-provider', 5435 props: { 5436 root: Boolean 5437 }, 5438 computed: { 5439 isDark() { 5440 return this.root ? this.rootIsDark : _mixins_themeable__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.options.computed.isDark.call(this); 5441 } 5442 }, 5443 render() { 5444 /* istanbul ignore next */ 5445 return this.$slots.default && this.$slots.default.find(node => !node.isComment && node.text !== ' '); 5446 } 5447})); 5448 5449/***/ }), 5450 5451/***/ 7803: 5452/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5453 5454"use strict"; 5455 5456// EXPORTS 5457__webpack_require__.d(__webpack_exports__, { 5458 Z: function() { return /* binding */ VToolbar; } 5459}); 5460 5461// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 5462var web_dom_iterable = __webpack_require__(1181); 5463// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 5 modules 5464var slicedToArray = __webpack_require__(7625); 5465// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 5466var defineProperty = __webpack_require__(1180); 5467;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VToolbar/VToolbar.sass 5468// extracted by mini-css-extract-plugin 5469 5470// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VSheet/VSheet.js + 1 modules 5471var VSheet = __webpack_require__(1685); 5472// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VImg/VImg.js + 4 modules 5473var VImg = __webpack_require__(5937); 5474// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 5475var helpers = __webpack_require__(6539); 5476// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 5477var console = __webpack_require__(9206); 5478;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VToolbar/VToolbar.js 5479 5480 5481 5482function 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; } 5483function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
5483 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 5484// Styles 5485 // Extensions 5486 5487 // Components 5488 5489 // Utilities 5490 5491 5492 5493/* @vue/component */ 5494 5495/* harmony default export */ var VToolbar = (VSheet/* default */.Z.extend({ 5496 name: 'v-toolbar', 5497 props: { 5498 absolute: Boolean, 5499 bottom: Boolean, 5500 collapse: Boolean, 5501 dense: Boolean, 5502 extended: Boolean, 5503 extensionHeight: { 5504 default: 48, 5505 type: [Number, String] 5506 }, 5507 flat: Boolean, 5508 floating: Boolean, 5509 prominent: Boolean, 5510 short: Boolean, 5511 src: { 5512 type: [String, Object], 5513 default: '' 5514 }, 5515 tag: { 5516 type: String, 5517 default: 'header' 5518 } 5519 }, 5520 data: () => ({ 5521 isExtended: false 5522 }), 5523 computed: { 5524 computedHeight() { 5525 const height = this.computedContentHeight; 5526 if (!this.isExtended) return height; 5527 const extensionHeight = parseInt(this.extensionHeight); 5528 return this.isCollapsed ? height : height + (!isNaN(extensionHeight) ? extensionHeight : 0); 5529 }, 5530 computedContentHeight() { 5531 if (this.height) return parseInt(this.height); 5532 if (this.isProminent && this.dense) return 96; 5533 if (this.isProminent && this.short) return 112; 5534 if (this.isProminent) return 128; 5535 if (this.dense) return 48; 5536 if (this.short || this.$vuetify.breakpoint.smAndDown) return 56; 5537 return 64; 5538 }, 5539 classes() { 5540 return _objectSpread(_objectSpread({}, VSheet/* default */.Z.options.computed.classes.call(this)), {}, { 5541 'v-toolbar': true, 5542 'v-toolbar--absolute': this.absolute, 5543 'v-toolbar--bottom': this.bottom, 5544 'v-toolbar--collapse': this.collapse, 5545 'v-toolbar--collapsed': this.isCollapsed, 5546 'v-toolbar--dense': this.dense, 5547 'v-toolbar--extended': this.isExtended, 5548 'v-toolbar--flat': this.flat, 5549 'v-toolbar--floating': this.floating, 5550 'v-toolbar--prominent': this.isProminent 5551 }); 5552 }, 5553 isCollapsed() { 5554 return this.collapse; 5555 }, 5556 isProminent() { 5557 return this.prominent; 5558 }, 5559 styles() { 5560 return _objectSpread(_objectSpread({}, this.measurableStyles), {}, { 5561 height: (0,helpers/* convertToUnit */.kb)(this.computedHeight) 5562 }); 5563 } 5564 }, 5565 created() { 5566 const breakingProps = [['app', '<v-app-bar app>'], ['manual-scroll', '<v-app-bar :value="false">'], ['clipped-left', '<v-app-bar clipped-left>'], ['clipped-right', '<v-app-bar clipped-right>'], ['inverted-scroll', '<v-app-bar inverted-scroll>'], ['scroll-off-screen', '<v-app-bar scroll-off-screen>'], ['scroll-target', '<v-app-bar scroll-target>'], ['scroll-threshold', '<v-app-bar scroll-threshold>'], ['card', '<v-app-bar flat>']]; 5567 /* istanbul ignore next */ 5568 5569 breakingProps.forEach(_ref => { 5570 let _ref2 = (0,slicedToArray/* default */.Z)(_ref, 2), 5571 original = _ref2[0], 5572 replacement = _ref2[1]; 5573 if (this.$attrs.hasOwnProperty(original)) (0,console/* breaking */.fK)(original, replacement, this); 5574 }); 5575 }, 5576 methods: { 5577 genBackground() { 5578 const props = { 5579 height: (0,helpers/* convertToUnit */.kb)(this.computedHeight), 5580 src: this.src 5581 }; 5582 const image = this.$scopedSlots.img ? this.$scopedSlots.img({ 5583 props 5584 }) : this.$createElement(VImg/* default */.Z, { 5585 props 5586 }); 5587 return this.$createElement('div', { 5588 staticClass: 'v-toolbar__image' 5589 }, [image]); 5590 }, 5591 genContent() { 5592 return this.$createElement('div', { 5593 staticClass: 'v-toolbar__content', 5594 style: { 5595 height: (0,helpers/* convertToUnit */.kb)(this.computedContentHeight) 5596 } 5597 }, (0,helpers/* getSlot */.z9)(this)); 5598 }, 5599 genExtension() { 5600 return this.$createElement('div', { 5601 staticClass: 'v-toolbar__extension', 5602 style: { 5603 height: (0,helpers/* convertToUnit */.kb)(this.extensionHeight) 5604 } 5605 }, (0,helpers/* getSlot */.z9)(this, 'extension')); 5606 } 5607 }, 5608 render(h) { 5609 this.isExtended = this.extended || !!this.$scopedSlots.extension; 5610 const children = [this.genContent()];
5611 const data = this.setBackgroundColor(this.color, { 5612 class: this.classes, 5613 style: this.styles, 5614 on: this.$listeners 5615 }); 5616 if (this.isExtended) children.push(this.genExtension()); 5617 if (this.src || this.$scopedSlots.img) children.unshift(this.genBackground()); 5618 return h(this.tag, data, children); 5619 } 5620})); 5621 5622/***/ }), 5623 5624/***/ 4453: 5625/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5626 5627"use strict"; 5628/* harmony export */ __webpack_require__.d(__webpack_exports__, { 5629/* harmony export */ lj: function() { return /* binding */ VToolbarItems; }, 5630/* harmony export */ qW: function() { return /* binding */ VToolbarTitle; } 5631/* harmony export */ }); 5632/* harmony import */ var _VToolbar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7803); 5633/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6539); 5634// Components 5635 // Utilities 5636 5637 5638const VToolbarTitle = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-toolbar__title'); 5639const VToolbarItems = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_0__/* .createSimpleFunctional */ .Ji)('v-toolbar__items'); 5640 5641/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ({ 5642 $_vuetify_subcomponents: { 5643 VToolbar: _VToolbar__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z, 5644 VToolbarItems, 5645 VToolbarTitle 5646 } 5647}); 5648 5649/***/ }), 5650 5651/***/ 6645: 5652/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5653 5654"use strict"; 5655 5656// EXPORTS 5657__webpack_require__.d(__webpack_exports__, { 5658 Z: function() { return /* binding */ VTooltip; } 5659}); 5660 5661;// CONCATENATED MODULE: ./node_modules/vuetify/src/components/VTooltip/VTooltip.sass 5662// extracted by mini-css-extract-plugin 5663 5664// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/activatable/index.js 5665var activatable = __webpack_require__(2994); 5666// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/colorable/index.js 5667var colorable = __webpack_require__(8390); 5668// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/delayable/index.js 5669var delayable = __webpack_require__(2838); 5670// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/dependent/index.js 5671var dependent = __webpack_require__(1511); 5672// EXTERNAL MODULE: ./node_modules/vuetify/lib/mixins/menuable/index.js 5673var menuable = __webpack_require__(7403); 5674// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 5675var helpers = __webpack_require__(6539); 5676// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 5677var console = __webpack_require__(9206); 5678// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mixins.js 5679var mixins = __webpack_require__(9547); 5680;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VTooltip/VTooltip.js 5681 // Mixins 5682 5683 5684 5685 5686 5687 // Helpers 5688 5689 5690 5691 5692/* @vue/component */ 5693 5694/* harmony default export */ var VTooltip = ((0,mixins/* default */.Z)(colorable/* default */.Z, delayable/* default */.Z, dependent/* default */.Z, menuable/* default */.Z).extend({ 5695 name: 'v-tooltip', 5696 props: { 5697 closeDelay: { 5698 type: [Number, String], 5699 default: 0 5700 }, 5701 disabled: Boolean, 5702 openDelay: { 5703 type: [Number, String], 5704 default: 0 5705 }, 5706 openOnHover: { 5707 type: Boolean, 5708 default: true 5709 }, 5710 openOnFocus: { 5711 type: Boolean, 5712 default: true 5713 }, 5714 tag: { 5715 type: String, 5716 default: 'span' 5717 }, 5718 transition: String 5719 }, 5720 data: () => ({ 5721 calculatedMinWidth: 0, 5722 closeDependents: false 5723 }), 5724 computed: { 5725 calculatedLeft() { 5726 const _this$dimensions = this.dimensions, 5727 activator = _this$dimensions.activator, 5728 content = _this$dimensions.content; 5729 const unknown = !this.bottom && !this.left && !this.top && !this.right; 5730 const activatorLeft = this.attach !== false ? activator.offsetLeft : activator.left; 5731 let left = 0; 5732 if (this.top || this.bottom || unknown) { 5733 left = activatorLeft + activator.width / 2 - content.width / 2; 5734 } else if (this.left || this.right) { 5735 left = activatorLeft + (this.right ? activator.width : -content.width) + (this.right ? 10 : -10); 5736 } 5737 if (this.nudgeLeft) left -= parseInt(this.nudgeLeft); 5738 if (this.nudgeRight) left += parseInt(this.nudgeRight); 5739 return `${this.calcXOverflow(left, this.dimensions.content.width)}px`; 5740 }, 5741 calculatedTop() { 5742 const _this$dimensions2 = this.dimensions, 5743 activator = _this$dimensions2.activator, 5744 content = _this$dimensions2.content; 5745 const activatorTop = this.attach !== false ? activator.offsetTop : activator.top; 5746 let top = 0; 5747 if (this.top || this.bottom) { 5748 top = activatorTop + (this.bottom ? activator.height : -content.height) + (this.bottom ? 10 : -10); 5749 } else if (this.left || this.right) { 5750 top = activatorTop + activator.height / 2 - content.height / 2; 5751 } 5752 if (this.nudgeTop) top -= parseInt(this.nudgeTop); 5753 if (this.nudgeBottom) top += parseInt(this.nudgeBottom); 5754 if (this.attach === false) top += this.pageYOffset; 5755 return `${this.calcYOverflow(top)}px`; 5756 }, 5757 classes() { 5758 return { 5759 'v-tooltip--top': this.top, 5760 'v-tooltip--right': this.right, 5761 'v-tooltip--bottom': this.bottom, 5762 'v-tooltip--left': this.left, 5763 'v-tooltip--attached': this.attach === '' || this.attach === true || this.attach === 'attach' 5764 }; 5765 }, 5766 computedTransition() { 5767 if (this.transition) return this.transition; 5768 return this.isActive ? 'scale-transition' : 'fade-transition'; 5769 }, 5770 offsetY() { 5771 return this.top || this.bottom; 5772 }, 5773 offsetX() { 5774 return this.left || this.right; 5775 }, 5776 styles() { 5777 return { 5778 left: this.calculatedLeft, 5779 maxWidth: (0,helpers/* convertToUnit */.kb)(this.maxWidth), 5780 minWidth: (0,helpers/* convertToUnit */.kb)(this.minWidth), 5781 top: this.calculatedTop, 5782 zIndex: this.zIndex || this.activeZIndex 5783 }; 5784 } 5785 }, 5786 beforeMount() { 5787 this.$nextTick(() => { 5788 this.value && this.callActivate(); 5789 }); 5790 }, 5791 mounted() { 5792 if ((0,helpers/* getSlotType */.sp)(this, 'activator', true) === 'v-slot') { 5793 (0,console/* consoleError */.N6)(`v-tooltip's activator slot must be bound, try '<template #activator="data"><v-btn v-on="data.on>'`, this); 5794 } 5795 }, 5796 methods: { 5797 activate() { 5798 // Update coordinates and dimensions of menu 5799 // and its activator
5800 this.updateDimensions(); // Start the transition 5801 5802 requestAnimationFrame(this.startTransition); 5803 }, 5804 deactivate() { 5805 this.runDelay('close'); 5806 }, 5807 genActivatorListeners() { 5808 const listeners = activatable/* default */.Z.options.methods.genActivatorListeners.call(this); 5809 if (this.openOnFocus) { 5810 listeners.focus = e => { 5811 this.getActivator(e); 5812 this.runDelay('open'); 5813 }; 5814 listeners.blur = e => { 5815 this.getActivator(e); 5816 this.runDelay('close'); 5817 }; 5818 } 5819 listeners.keydown = e => { 5820 if (e.keyCode === helpers/* keyCodes */.Do.esc) { 5821 this.getActivator(e); 5822 this.runDelay('close'); 5823 } 5824 }; 5825 return listeners; 5826 }, 5827 genActivatorAttributes() { 5828 return { 5829 'aria-haspopup': true, 5830 'aria-expanded': String(this.isActive) 5831 }; 5832 }, 5833 genTransition() { 5834 const content = this.genContent(); 5835 if (!this.computedTransition) return content; 5836 return this.$createElement('transition', { 5837 props: { 5838 name: this.computedTransition 5839 } 5840 }, [content]); 5841 }, 5842 genContent() { 5843 return this.$createElement('div', this.setBackgroundColor(this.color, { 5844 staticClass: 'v-tooltip__content', 5845 class: { 5846 [this.contentClass]: true, 5847 menuable__content__active: this.isActive, 5848 'v-tooltip__content--fixed': this.activatorFixed 5849 }, 5850 style: this.styles, 5851 attrs: this.getScopeIdAttrs(), 5852 directives: [{ 5853 name: 'show', 5854 value: this.isContentActive 5855 }], 5856 ref: 'content' 5857 }), this.getContentSlot()); 5858 } 5859 }, 5860 render(h) { 5861 return h(this.tag, { 5862 staticClass: 'v-tooltip', 5863 class: this.classes 5864 }, [this.showLazyContent(() => [this.genTransition()]), this.genActivator()]); 5865 } 5866})); 5867 5868/***/ }), 5869 5870/***/ 5712: 5871/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 5872 5873"use strict"; 5874 5875// EXPORTS 5876__webpack_require__.d(__webpack_exports__, { 5877 Fx: function() { return /* binding */ VExpandTransition; }, 5878 Zq: function() { return /* binding */ VExpandXTransition; }, 5879 b0: function() { return /* binding */ VFabTransition; }, 5880 Z5: function() { return /* binding */ VFadeTransition; }, 5881 Qn: function() { return /* binding */ VSlideXTransition; }, 5882 YV: function() { return /* binding */ VTabReverseTransition; }, 5883 n6: function() { return /* binding */ VTabTransition; } 5884}); 5885 5886// UNUSED EXPORTS: VCarouselReverseTransition, VCarouselTransition, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VMenuTransition, VScaleTransition, VScrollXReverseTransition, VScrollXTransition, VScrollYReverseTransition, VScrollYTransition, VSlideXReverseTransition, VSlideYReverseTransition, VSlideYTransition, default 5887 5888// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/mergeData.js 5889var mergeData = __webpack_require__(8097); 5890;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/transitions/createTransition.js 5891 5892function mergeTransitions() { 5893 let dest = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 5894 for (var _len = arguments.length, transitions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 5895 transitions[_key - 1] = arguments[_key]; 5896 } 5897 /* eslint-disable-next-line no-array-constructor */ 5898 return Array().concat(dest, ...transitions); 5899} 5900function createSimpleTransition(name) { 5901 let origin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top center 0'; 5902 let mode = arguments.length > 2 ? arguments[2] : undefined; 5903 return { 5904 name, 5905 functional: true, 5906 props: { 5907 group: { 5908 type: Boolean, 5909 default: false 5910 }, 5911 hideOnLeave: { 5912 type: Boolean, 5913 default: false 5914 }, 5915 leaveAbsolute: { 5916 type: Boolean, 5917 default: false 5918 }, 5919 mode: { 5920 type: String, 5921 default: mode 5922 }, 5923 origin: { 5924 type: String, 5925 default: origin 5926 } 5927 }, 5928 render(h, context) { 5929 const tag = `transition${context.props.group ? '-group' : ''}`; 5930 const data = { 5931 props: { 5932 name, 5933 mode: context.props.mode 5934 }, 5935 on: { 5936 beforeEnter(el) { 5937 el.style.transformOrigin = context.props.origin; 5938 el.style.webkitTransformOrigin = context.props.origin; 5939 } 5940 } 5941 }; 5942 if (context.props.leaveAbsolute) { 5943 data.on.leave = mergeTransitions(data.on.leave, el => { 5944 const offsetTop = el.offsetTop, 5945 offsetLeft = el.offsetLeft, 5946 offsetWidth = el.offsetWidth, 5947 offsetHeight = el.offsetHeight; 5948 el._transitionInitialStyles = { 5949 position: el.style.position, 5950 top: el.style.top, 5951 left: el.style.left, 5952 width: el.style.width, 5953 height: el.style.height 5954 }; 5955 el.style.position = 'absolute'; 5956 el.style.top = offsetTop + 'px'; 5957 el.style.left = offsetLeft + 'px'; 5958 el.style.width = offsetWidth + 'px'; 5959 el.style.height = offsetHeight + 'px'; 5960 }); 5961 data.on.afterLeave = mergeTransitions(data.on.afterLeave, el => { 5962 if (el && el._transitionInitialStyles) { 5963 const _el$_transitionInitia = el._transitionInitialStyles, 5964 position = _el$_transitionInitia.position, 5965 top = _el$_transitionInitia.top, 5966 left = _el$_transitionInitia.left, 5967 width = _el$_transitionInitia.width, 5968 height = _el$_transitionInitia.height; 5969 delete el._transitionInitialStyles; 5970 el.style.position = position || ''; 5971 el.style.top = top || ''; 5972 el.style.left = left || ''; 5973 el.style.width = width || ''; 5974 el.style.height = height || ''; 5975 } 5976 }); 5977 } 5978 if (context.props.hideOnLeave) { 5979 data.on.leave = mergeTransitions(data.on.leave, el => { 5980 el.style.setProperty('display', 'none', 'important'); 5981 }); 5982 } 5983 return h(tag, (0,mergeData/* default */.ZP)(context.data, data), context.children); 5984 } 5985 }; 5986} 5987function createJavascriptTransition(name, functions) { 5988 let mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'in-out'; 5989 return { 5990 name, 5991 functional: true, 5992 props: { 5993 mode: { 5994 type: String, 5995 default: mode 5996 } 5997 }, 5998 render(h, context) { 5999 return h('transition', (0,mergeData/* default */.ZP)(context.data, { 6000 props: { 6001 name 6002 }, 6003 on: functions 6004 }), context.children); 6005 } 6006 }; 6007} 6008// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 6009var helpers = __webpack_require__(6539); 6010;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/transitions/expand-transition.js 6011 6012/* harmony default export */ function expand_transition() { 6013 let expandedParentClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; 6014 let x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
6015 const sizeProperty = x ? 'width' : 'height'; 6016 const offsetProperty = `offset${(0,helpers/* upperFirst */.jC)(sizeProperty)}`; 6017 return { 6018 beforeEnter(el) { 6019 el._parent = el.parentNode; 6020 el._initialStyle = { 6021 transition: el.style.transition, 6022 overflow: el.style.overflow, 6023 [sizeProperty]: el.style[sizeProperty] 6024 }; 6025 }, 6026 enter(el) { 6027 const initialStyle = el._initialStyle; 6028 el.style.setProperty('transition', 'none', 'important'); // Hide overflow to account for collapsed margins in the calculated height 6029 6030 el.style.overflow = 'hidden'; 6031 const offset = `${el[offsetProperty]}px`; 6032 el.style[sizeProperty] = '0'; 6033 void el.offsetHeight; // force reflow 6034 6035 el.style.transition = initialStyle.transition; 6036 if (expandedParentClass && el._parent) { 6037 el._parent.classList.add(expandedParentClass); 6038 } 6039 requestAnimationFrame(() => { 6040 el.style[sizeProperty] = offset; 6041 }); 6042 }, 6043 afterEnter: resetStyles, 6044 enterCancelled: resetStyles, 6045 leave(el) { 6046 el._initialStyle = { 6047 transition: '', 6048 overflow: el.style.overflow, 6049 [sizeProperty]: el.style[sizeProperty] 6050 }; 6051 el.style.overflow = 'hidden'; 6052 el.style[sizeProperty] = `${el[offsetProperty]}px`; 6053 void el.offsetHeight; // force reflow 6054 6055 requestAnimationFrame(() => el.style[sizeProperty] = '0'); 6056 }, 6057 afterLeave, 6058 leaveCancelled: afterLeave 6059 }; 6060 function afterLeave(el) { 6061 if (expandedParentClass && el._parent) { 6062 el._parent.classList.remove(expandedParentClass); 6063 } 6064 resetStyles(el); 6065 } 6066 function resetStyles(el) { 6067 const size = el._initialStyle[sizeProperty]; 6068 el.style.overflow = el._initialStyle.overflow; 6069 if (size != null) el.style[sizeProperty] = size; 6070 delete el._initialStyle; 6071 } 6072} 6073;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/transitions/index.js 6074 6075 // Component specific transitions 6076
6077const VCarouselTransition = createSimpleTransition('carousel-transition'); 6078const VCarouselReverseTransition = createSimpleTransition('carousel-reverse-transition'); 6079const VTabTransition = createSimpleTransition('tab-transition'); 6080const VTabReverseTransition = createSimpleTransition('tab-reverse-transition'); 6081const VMenuTransition = createSimpleTransition('menu-transition'); 6082const VFabTransition = createSimpleTransition('fab-transition', 'center center', 'out-in'); // Generic transitions 6083 6084const VDialogTransition = createSimpleTransition('dialog-transition'); 6085const VDialogBottomTransition = createSimpleTransition('dialog-bottom-transition'); 6086const VDialogTopTransition = createSimpleTransition('dialog-top-transition'); 6087const VFadeTransition = createSimpleTransition('fade-transition'); 6088const VScaleTransition = createSimpleTransition('scale-transition'); 6089const VScrollXTransition = createSimpleTransition('scroll-x-transition'); 6090const VScrollXReverseTransition = createSimpleTransition('scroll-x-reverse-transition'); 6091const VScrollYTransition = createSimpleTransition('scroll-y-transition'); 6092const VScrollYReverseTransition = createSimpleTransition('scroll-y-reverse-transition'); 6093const VSlideXTransition = createSimpleTransition('slide-x-transition'); 6094const VSlideXReverseTransition = createSimpleTransition('slide-x-reverse-transition'); 6095const VSlideYTransition = createSimpleTransition('slide-y-transition'); 6096const VSlideYReverseTransition = createSimpleTransition('slide-y-reverse-transition'); // Javascript transitions 6097 6098const VExpandTransition = createJavascriptTransition('expand-transition', expand_transition()); 6099const VExpandXTransition = createJavascriptTransition('expand-x-transition', expand_transition('', true)); 6100/* harmony default export */ var transitions = ({ 6101 $_vuetify_subcomponents: {
6102 VCarouselTransition, 6103 VCarouselReverseTransition, 6104 VDialogTransition, 6105 VDialogBottomTransition, 6106 VDialogTopTransition, 6107 VFabTransition, 6108 VFadeTransition, 6109 VMenuTransition, 6110 VScaleTransition, 6111 VScrollXTransition, 6112 VScrollXReverseTransition, 6113 VScrollYTransition, 6114 VScrollYReverseTransition, 6115 VSlideXTransition, 6116 VSlideXReverseTransition, 6117 VSlideYTransition, 6118 VSlideYReverseTransition, 6119 VTabReverseTransition, 6120 VTabTransition, 6121 VExpandTransition, 6122 VExpandXTransition 6123 } 6124}); 6125 6126/***/ }), 6127 6128/***/ 6974: 6129/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 6130 6131"use strict"; 6132/* unused harmony export ClickOutside */ 6133/* harmony import */ var _util_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8616); 6134 6135function defaultConditional() { 6136 return true; 6137} 6138function checkEvent(e, el, binding) { 6139 // The include element callbacks below can be expensive 6140 // so we should avoid calling them when we're not active. 6141 // Explicitly check for false to allow fallback compatibility 6142 // with non-toggleable components 6143 if (!e || checkIsActive(e, binding) === false) return false; // If we're clicking inside the shadowroot, then the app root doesn't get the same 6144 // level of introspection as to _what_ we're clicking. We want to check to see if 6145 // our target is the shadowroot parent container, and if it is, ignore. 6146 6147 const root = (0,_util_dom__WEBPACK_IMPORTED_MODULE_0__/* .attachedRoot */ .e)(el); 6148 if (typeof ShadowRoot !== 'undefined' && root instanceof ShadowRoot && root.host === e.target) return false; // Check if additional elements were passed to be included in check 6149 // (click must be outside all included elements, if any) 6150 6151 const elements = (typeof binding.value === 'object' && binding.value.include || (() => []))(); // Add the root element for the component this directive was defined on 6152 6153 elements.push(el); // Check if it's a click outside our elements, and then if our callback returns true. 6154 // Non-toggleable components should take action in their callback and return falsy. 6155 // Toggleable can return true if it wants to deactivate. 6156 // Note that, because we're in the capture phase, this callback will occur before 6157 // the bubbling click event on any outside elements. 6158 6159 return !elements.some(el => el.contains(e.target)); 6160} 6161function checkIsActive(e, binding) { 6162 const isActive = typeof binding.value === 'object' && binding.value.closeConditional || defaultConditional; 6163 return isActive(e); 6164} 6165function directive(e, el, binding) { 6166 const handler = typeof binding.value === 'function' ? binding.value : binding.value.handler; 6167 el._clickOutside.lastMousedownWasOutside && checkEvent(e, el, binding) && setTimeout(() => { 6168 checkIsActive(e, binding) && handler && handler(e); 6169 }, 0); 6170} 6171function handleShadow(el, callback) { 6172 const root = (0,_util_dom__WEBPACK_IMPORTED_MODULE_0__/* .attachedRoot */ .e)(el); 6173 callback(document); 6174 if (typeof ShadowRoot !== 'undefined' && root instanceof ShadowRoot) { 6175 callback(root); 6176 } 6177} 6178const ClickOutside = { 6179 // [data-app] may not be found 6180 // if using bind, inserted makes 6181 // sure that the root element is 6182 // available, iOS does not support 6183 // clicks on body 6184 inserted(el, binding, vnode) { 6185 const onClick = e => directive(e, el, binding); 6186 const onMousedown = e => { 6187 el._clickOutside.lastMousedownWasOutside = checkEvent(e, el, binding); 6188 }; 6189 handleShadow(el, app => { 6190 app.addEventListener('click', onClick, true); 6191 app.addEventListener('mousedown', onMousedown, true); 6192 }); 6193 if (!el._clickOutside) { 6194 el._clickOutside = { 6195 lastMousedownWasOutside: true 6196 }; 6197 } 6198 el._clickOutside[vnode.context._uid] = { 6199 onClick, 6200 onMousedown 6201 }; 6202 }, 6203 unbind(el, binding, vnode) { 6204 if (!el._clickOutside) return; 6205 handleShadow(el, app => { 6206 var _a; 6207 if (!app || !((_a = el._clickOutside) === null || _a === void 0 ? void 0 : _a[vnode.context._uid])) return; 6208 const _el$_clickOutside$vno = el._clickOutside[vnode.context._uid], 6209 onClick = _el$_clickOutside$vno.onClick, 6210 onMousedown = _el$_clickOutside$vno.onMousedown; 6211 app.removeEventListener('click', onClick, true); 6212 app.removeEventListener('mousedown', onMousedown, true); 6213 }); 6214 delete el._clickOutside[vnode.context._uid]; 6215 } 6216}; 6217/* harmony default export */ __webpack_exports__.Z = (ClickOutside); 6218 6219/***/ }), 6220 6221/***/ 9106: 6222/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 6223 6224"use strict"; 6225/* unused harmony export Intersect */ 6226function inserted(el, binding, vnode) { 6227 if (typeof window === 'undefined' || !('IntersectionObserver' in window)) return; 6228 const modifiers = binding.modifiers || {}; 6229 const value = binding.value; 6230 const _ref = typeof value === 'object' ? value : { 6231 handler: value, 6232 options: {} 6233 }, 6234 handler = _ref.handler, 6235 options = _ref.options; 6236 const observer = new IntersectionObserver(function () { 6237 let entries = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 6238 let observer = arguments.length > 1 ? arguments[1] : undefined; 6239 var _a; 6240 const _observe = (_a = el._observe) === null || _a === void 0 ? void 0 : _a[vnode.context._uid]; 6241 if (!_observe) return; // Just in case, should never fire 6242 6243 const isIntersecting = entries.some(entry => entry.isIntersecting); // If is not quiet or has already been 6244 // initted, invoke the user callback 6245 6246 if (handler && (!modifiers.quiet || _observe.init) && (!modifiers.once || isIntersecting || _observe.init)) { 6247 handler(entries, observer, isIntersecting); 6248 } 6249 if (isIntersecting && modifiers.once) unbind(el, binding, vnode);else _observe.init = true; 6250 }, options); 6251 el._observe = Object(el._observe); 6252 el._observe[vnode.context._uid] = { 6253 init: false, 6254 observer 6255 }; 6256 observer.observe(el); 6257} 6258function unbind(el, binding, vnode) { 6259 var _a; 6260 const observe = (_a = el._observe) === null || _a === void 0 ? void 0 : _a[vnode.context._uid]; 6261 if (!observe) return; 6262 observe.observer.unobserve(el); 6263 delete el._observe[vnode.context._uid]; 6264} 6265const Intersect = { 6266 inserted, 6267 unbind 6268}; 6269/* harmony default export */ __webpack_exports__.Z = (Intersect); 6270 6271/***/ }), 6272 6273/***/ 6797:
6274/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 6275 6276"use strict"; 6277/* unused harmony export Resize */ 6278function inserted(el, binding, vnode) { 6279 const callback = binding.value; 6280 const options = binding.options || { 6281 passive: true 6282 }; 6283 window.addEventListener('resize', callback, options); 6284 el._onResize = Object(el._onResize); 6285 el._onResize[vnode.context._uid] = { 6286 callback, 6287 options 6288 }; 6289 if (!binding.modifiers || !binding.modifiers.quiet) { 6290 callback(); 6291 } 6292} 6293function unbind(el, binding, vnode) { 6294 var _a; 6295 if (!((_a = el._onResize) === null || _a === void 0 ? void 0 : _a[vnode.context._uid])) return; 6296 const _el$_onResize$vnode$c = el._onResize[vnode.context._uid], 6297 callback = _el$_onResize$vnode$c.callback, 6298 options = _el$_onResize$vnode$c.options; 6299 window.removeEventListener('resize', callback, options); 6300 delete el._onResize[vnode.context._uid]; 6301} 6302const Resize = { 6303 inserted, 6304 unbind 6305}; 6306/* harmony default export */ __webpack_exports__.Z = (Resize); 6307 6308/***/ }), 6309 6310/***/ 4261: 6311/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 6312 6313"use strict"; 6314 6315// EXPORTS 6316__webpack_require__.d(__webpack_exports__, { 6317 Z: function() { return /* binding */ ripple; } 6318}); 6319 6320// UNUSED EXPORTS: Ripple 6321 6322;// CONCATENATED MODULE: ./node_modules/vuetify/src/directives/ripple/VRipple.sass 6323// extracted by mini-css-extract-plugin 6324 6325// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 6326var helpers = __webpack_require__(6539); 6327;// CONCATENATED MODULE: ./node_modules/vuetify/lib/directives/ripple/index.js 6328// Styles 6329 // Utilities 6330 6331 6332 6333const DELAY_RIPPLE = 80; 6334function transform(el, value) { 6335 el.style.transform = value; 6336 el.style.webkitTransform = value; 6337} 6338function isTouchEvent(e) { 6339 return e.constructor.name === 'TouchEvent'; 6340} 6341function isKeyboardEvent(e) { 6342 return e.constructor.name === 'KeyboardEvent'; 6343} 6344const calculate = function calculate(e, el) { 6345 let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 6346 let localX = 0; 6347 let localY = 0; 6348 if (!isKeyboardEvent(e)) { 6349 const offset = el.getBoundingClientRect(); 6350 const target = isTouchEvent(e) ? e.touches[e.touches.length - 1] : e; 6351 localX = target.clientX - offset.left; 6352 localY = target.clientY - offset.top; 6353 } 6354 let radius = 0; 6355 let scale = 0.3; 6356 if (el._ripple && el._ripple.circle) { 6357 scale = 0.15; 6358 radius = el.clientWidth / 2; 6359 radius = value.center ? radius : radius + Math.sqrt((localX - radius) ** 2 + (localY - radius) ** 2) / 4; 6360 } else { 6361 radius = Math.sqrt(el.clientWidth ** 2 + el.clientHeight ** 2) / 2; 6362 } 6363 const centerX = `${(el.clientWidth - radius * 2) / 2}px`; 6364 const centerY = `${(el.clientHeight - radius * 2) / 2}px`; 6365 const x = value.center ? centerX : `${localX - radius}px`; 6366 const y = value.center ? centerY : `${localY - radius}px`; 6367 return { 6368 radius, 6369 scale, 6370 x, 6371 y, 6372 centerX, 6373 centerY 6374 }; 6375}; 6376const ripples = { 6377 /* eslint-disable max-statements */ 6378 show(e, el) { 6379 let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 6380 if (!el._ripple || !el._ripple.enabled) { 6381 return; 6382 } 6383 const container = document.createElement('span'); 6384 const animation = document.createElement('span'); 6385 container.appendChild(animation); 6386 container.className = 'v-ripple__container'; 6387 if (value.class) { 6388 container.className += ` ${value.class}`; 6389 } 6390 const _calculate = calculate(e, el, value), 6391 radius = _calculate.radius, 6392 scale = _calculate.scale, 6393 x = _calculate.x, 6394 y = _calculate.y, 6395 centerX = _calculate.centerX, 6396 centerY = _calculate.centerY; 6397 const size = `${radius * 2}px`; 6398 animation.className = 'v-ripple__animation'; 6399 animation.style.width = size; 6400 animation.style.height = size; 6401 el.appendChild(container); 6402 const computed = window.getComputedStyle(el); 6403 if (computed && computed.position === 'static') { 6404 el.style.position = 'relative'; 6405 el.dataset.previousPosition = 'static'; 6406 } 6407 animation.classList.add('v-ripple__animation--enter'); 6408 animation.classList.add('v-ripple__animation--visible'); 6409 transform(animation, `translate(${x}, ${y}) scale3d(${scale},${scale},${scale})`); 6410 animation.dataset.activated = String(performance.now()); 6411 setTimeout(() => { 6412 animation.classList.remove('v-ripple__animation--enter'); 6413 animation.classList.add('v-ripple__animation--in'); 6414 transform(animation, `translate(${centerX}, ${centerY}) scale3d(1,1,1)`); 6415 }, 0); 6416 }, 6417 hide(el) { 6418 if (!el || !el._ripple || !el._ripple.enabled) return; 6419 const ripples = el.getElementsByClassName('v-ripple__animation'); 6420 if (ripples.length === 0) return; 6421 const animation = ripples[ripples.length - 1]; 6422 if (animation.dataset.isHiding) return;else animation.dataset.isHiding = 'true'; 6423 const diff = performance.now() - Number(animation.dataset.activated);
6424 const delay = Math.max(250 - diff, 0); 6425 setTimeout(() => { 6426 animation.classList.remove('v-ripple__animation--in'); 6427 animation.classList.add('v-ripple__animation--out'); 6428 setTimeout(() => { 6429 var _a; 6430 const ripples = el.getElementsByClassName('v-ripple__animation'); 6431 if (ripples.length === 1 && el.dataset.previousPosition) { 6432 el.style.position = el.dataset.previousPosition; 6433 delete el.dataset.previousPosition; 6434 } 6435 if (((_a = animation.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode) === el) el.removeChild(animation.parentNode); 6436 }, 300); 6437 }, delay); 6438 } 6439}; 6440function isRippleEnabled(value) { 6441 return typeof value === 'undefined' || !!value; 6442} 6443function rippleShow(e) { 6444 const value = {}; 6445 const element = e.currentTarget; 6446 if (!element || !element._ripple || element._ripple.touched || e.rippleStop) return; // Don't allow the event to trigger ripples on any other elements 6447 6448 e.rippleStop = true; 6449 if (isTouchEvent(e)) { 6450 element._ripple.touched = true; 6451 element._ripple.isTouch = true; 6452 } else { 6453 // It's possible for touch events to fire 6454 // as mouse events on Android/iOS, this 6455 // will skip the event call if it has 6456 // already been registered as touch 6457 if (element._ripple.isTouch) return; 6458 } 6459 value.center = element._ripple.centered || isKeyboardEvent(e); 6460 if (element._ripple.class) { 6461 value.class = element._ripple.class; 6462 } 6463 if (isTouchEvent(e)) { 6464 // already queued that shows or hides the ripple 6465 if (element._ripple.showTimerCommit) return; 6466 element._ripple.showTimerCommit = () => { 6467 ripples.show(e, element, value); 6468 }; 6469 element._ripple.showTimer = window.setTimeout(() => { 6470 if (element && element._ripple && element._ripple.showTimerCommit) { 6471 element._ripple.showTimerCommit(); 6472 element._ripple.showTimerCommit = null; 6473 } 6474 }, DELAY_RIPPLE); 6475 } else { 6476 ripples.show(e, element, value); 6477 } 6478} 6479function rippleHide(e) { 6480 const element = e.currentTarget; 6481 if (!element || !element._ripple) return; 6482 window.clearTimeout(element._ripple.showTimer); // The touch interaction occurs before the show timer is triggered. 6483 // We still want to show ripple effect. 6484 6485 if (e.type === 'touchend' && element._ripple.showTimerCommit) { 6486 element._ripple.showTimerCommit(); 6487 element._ripple.showTimerCommit = null; // re-queue ripple hiding 6488 6489 element._ripple.showTimer = setTimeout(() => { 6490 rippleHide(e); 6491 }); 6492 return; 6493 } 6494 window.setTimeout(() => { 6495 if (element._ripple) { 6496 element._ripple.touched = false; 6497 } 6498 }); 6499 ripples.hide(element); 6500} 6501function rippleCancelShow(e) { 6502 const element = e.currentTarget; 6503 if (!element || !element._ripple) return; 6504 if (element._ripple.showTimerCommit) { 6505 element._ripple.showTimerCommit = null; 6506 } 6507 window.clearTimeout(element._ripple.showTimer); 6508} 6509let keyboardRipple = false; 6510function keyboardRippleShow(e) { 6511 if (!keyboardRipple && (e.keyCode === helpers/* keyCodes */.Do.enter || e.keyCode === helpers/* keyCodes */.Do.space)) { 6512 keyboardRipple = true; 6513 rippleShow(e); 6514 } 6515} 6516function keyboardRippleHide(e) { 6517 keyboardRipple = false; 6518 rippleHide(e); 6519} 6520function focusRippleHide(e) { 6521 if (keyboardRipple === true) { 6522 keyboardRipple = false; 6523 rippleHide(e); 6524 } 6525} 6526function updateRipple(el, binding, wasEnabled) { 6527 const enabled = isRippleEnabled(binding.value); 6528 if (!enabled) { 6529 ripples.hide(el); 6530 } 6531 el._ripple = el._ripple || {}; 6532 el._ripple.enabled = enabled; 6533 const value = binding.value || {}; 6534 if (value.center) { 6535 el._ripple.centered = true; 6536 } 6537 if (value.class) { 6538 el._ripple.class = binding.value.class; 6539 } 6540 if (value.circle) { 6541 el._ripple.circle = value.circle; 6542 } 6543 if (enabled && !wasEnabled) { 6544 el.addEventListener('touchstart', rippleShow, { 6545 passive: true 6546 }); 6547 el.addEventListener('touchend', rippleHide, { 6548 passive: true 6549 }); 6550 el.addEventListener('touchmove', rippleCancelShow, { 6551 passive: true 6552 }); 6553 el.addEventListener('touchcancel', rippleHide); 6554 el.addEventListener('mousedown', rippleShow); 6555 el.addEventListener('mouseup', rippleHide); 6556 el.addEventListener('mouseleave', rippleHide); 6557 el.addEventListener('keydown', keyboardRippleShow); 6558 el.addEventListener('keyup', keyboardRippleHide); 6559 el.addEventListener('blur', focusRippleHide); // Anchor tags can be dragged, causes other hides to fail - #1537 6560 6561 el.addEventListener('dragstart', rippleHide, { 6562 passive: true 6563 }); 6564 } else if (!enabled && wasEnabled) { 6565 removeListeners(el); 6566 } 6567} 6568function removeListeners(el) { 6569 el.removeEventListener('mousedown', rippleShow); 6570 el.removeEventListener('touchstart', rippleShow); 6571 el.removeEventListener('touchend', rippleHide); 6572 el.removeEventListener('touchmove', rippleCancelShow); 6573 el.removeEventListener('touchcancel', rippleHide); 6574 el.removeEventListener('mouseup', rippleHide); 6575 el.removeEventListener('mouseleave', rippleHide); 6576 el.removeEventListener('keydown', keyboardRippleShow); 6577 el.removeEventListener('keyup', keyboardRippleHide); 6578 el.removeEventListener('dragstart', rippleHide); 6579 el.removeEventListener('blur', focusRippleHide); 6580} 6581function directive(el, binding, node) { 6582 updateRipple(el, binding, false); 6583 if (false) {} 6584} 6585function unbind(el) { 6586 delete el._ripple; 6587 removeListeners(el); 6588} 6589function update(el, binding) { 6590 if (binding.value === binding.oldValue) { 6591 return; 6592 } 6593 const wasEnabled = isRippleEnabled(binding.oldValue); 6594 updateRipple(el, binding, wasEnabled); 6595} 6596const Ripple = { 6597 bind: directive, 6598 unbind, 6599 update 6600}; 6601/* harmony default export */ var ripple = (Ripple); 6602 6603/***/ }), 6604 6605/***/ 3359: 6606/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 6607 6608"use strict"; 6609 6610// EXPORTS 6611__webpack_require__.d(__webpack_exports__, { 6612 Z: function() { return /* binding */ Vuetify; } 6613}); 6614 6615// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 6616var web_dom_iterable = __webpack_require__(1181); 6617// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 6618var vue_esm = __webpack_require__(538); 6619// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/console.js 6620var console = __webpack_require__(9206); 6621;// CONCATENATED MODULE: ./node_modules/vuetify/lib/install.js 6622 6623 6624function install(Vue) { 6625 let args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 6626 if (install.installed) return; 6627 install.installed = true; 6628 if (vue_esm/* default */.ZP !== Vue) { 6629 (0,console/* consoleError */.N6)(`Multiple instances of Vue detected 6630See https://github.com/vuetifyjs/vuetify/issues/4068 6631 6632If you're seeing "$attrs is readonly", it's caused by this`); 6633 } 6634 const components = args.components || {}; 6635 const directives = args.directives || {}; 6636 for (const name in directives) { 6637 const directive = directives[name]; 6638 Vue.directive(name, directive); 6639 } 6640 (function registerComponents(components) { 6641 if (components) { 6642 for (const key in components) { 6643 const component = components[key]; 6644 if (component && !registerComponents(component.$_vuetify_subcomponents)) { 6645 Vue.component(key, component); 6646 } 6647 } 6648 return true; 6649 } 6650 return false;
6651 })(components); // Used to avoid multiple mixins being setup 6652 // when in dev mode and hot module reload 6653 // https://github.com/vuejs/vue/issues/5089#issuecomment-284260111 6654 6655 if (Vue.$_vuetify_installed) return; 6656 Vue.$_vuetify_installed = true; 6657 Vue.mixin({ 6658 beforeCreate() { 6659 const options = this.$options; 6660 if (options.vuetify) { 6661 options.vuetify.init(this, this.$ssrContext); 6662 this.$vuetify = Vue.observable(options.vuetify.framework); 6663 } else { 6664 this.$vuetify = options.parent && options.parent.$vuetify || this; 6665 } 6666 }, 6667 beforeMount() { 6668 // @ts-ignore 6669 if (this.$options.vuetify && this.$el && this.$el.hasAttribute('data-server-rendered')) { 6670 // @ts-ignore 6671 this.$vuetify.isHydrating = true; // @ts-ignore 6672 6673 this.$vuetify.breakpoint.update(true); 6674 } 6675 }, 6676 mounted() { 6677 // @ts-ignore 6678 if (this.$options.vuetify && this.$vuetify.isHydrating) { 6679 // @ts-ignore 6680 this.$vuetify.isHydrating = false; // @ts-ignore 6681 6682 this.$vuetify.breakpoint.update(); 6683 } 6684 } 6685 }); 6686} 6687// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules 6688var objectWithoutProperties = __webpack_require__(91); 6689;// CONCATENATED MODULE: ./node_modules/vuetify/src/styles/main.sass 6690// extracted by mini-css-extract-plugin 6691 6692;// CONCATENATED MODULE: ./node_modules/vuetify/lib/locale/en.js 6693/* harmony default export */ var en = ({ 6694 badge: 'Badge', 6695 close: 'Close', 6696 dataIterator: { 6697 noResultsText: 'No matching records found', 6698 loadingText: 'Loading items...' 6699 }, 6700 dataTable: { 6701 itemsPerPageText: 'Rows per page:', 6702 ariaLabel: { 6703 sortDescending: 'Sorted descending.', 6704 sortAscending: 'Sorted ascending.', 6705 sortNone: 'Not sorted.', 6706 activateNone: 'Activate to remove sorting.', 6707 activateDescending: 'Activate to sort descending.', 6708 activateAscending: 'Activate to sort ascending.' 6709 }, 6710 sortBy: 'Sort by' 6711 }, 6712 dataFooter: { 6713 itemsPerPageText: 'Items per page:', 6714 itemsPerPageAll: 'All', 6715 nextPage: 'Next page', 6716 prevPage: 'Previous page', 6717 firstPage: 'First page', 6718 lastPage: 'Last page', 6719 pageText: '{0}-{1} of {2}' 6720 }, 6721 datePicker: { 6722 itemsSelected: '{0} selected', 6723 nextMonthAriaLabel: 'Next month', 6724 nextYearAriaLabel: 'Next year', 6725 prevMonthAriaLabel: 'Previous month', 6726 prevYearAriaLabel: 'Previous year' 6727 }, 6728 noDataText: 'No data available', 6729 carousel: { 6730 prev: 'Previous visual', 6731 next: 'Next visual', 6732 ariaLabel: { 6733 delimiter: 'Carousel slide {0} of {1}' 6734 } 6735 }, 6736 calendar: { 6737 moreEvents: '{0} more' 6738 }, 6739 input: { 6740 clear: 'Clear {0}', 6741 prependAction: '{0} prepended action', 6742 appendAction: '{0} appended action' 6743 }, 6744 fileInput: { 6745 counter: '{0} files', 6746 counterSize: '{0} files ({1} in total)' 6747 }, 6748 timePicker: { 6749 am: 'AM', 6750 pm: 'PM' 6751 }, 6752 pagination: { 6753 ariaLabel: { 6754 wrapper: 'Pagination Navigation', 6755 next: 'Next page', 6756 previous: 'Previous page', 6757 page: 'Goto Page {0}', 6758 currentPage: 'Current Page, Page {0}' 6759 } 6760 }, 6761 rating: { 6762 ariaLabel: { 6763 icon: 'Rating {0} of {1}' 6764 } 6765 }, 6766 loading: 'Loading...' 6767}); 6768;// CONCATENATED MODULE: ./node_modules/vuetify/lib/presets/default/index.js 6769// Styles 6770 // Locale 6771 6772 6773const default_preset = { 6774 breakpoint: { 6775 // TODO: update to MD2 spec in v3 - 1280 6776 mobileBreakpoint: 1264, 6777 scrollBarWidth: 16, 6778 thresholds: { 6779 xs: 600, 6780 sm: 960, 6781 md: 1280, 6782 lg: 1920 6783 } 6784 }, 6785 icons: { 6786 // TODO: remove v3 6787 iconfont: 'mdi', 6788 values: {} 6789 }, 6790 lang: { 6791 current: 'en', 6792 locales: { 6793 en: en 6794 }, 6795 // Default translator exists in lang service 6796 t: undefined 6797 }, 6798 rtl: false, 6799 theme: { 6800 dark: false, 6801 default: 'light', 6802 disable: false, 6803 options: { 6804 cspNonce: undefined, 6805 customProperties: undefined, 6806 minifyTheme: undefined, 6807 themeCache: undefined, 6808 variations: true 6809 }, 6810 themes: { 6811 light: { 6812 primary: '#1976D2', 6813 secondary: '#424242', 6814 accent: '#82B1FF',
6815 error: '#FF5252', 6816 info: '#2196F3', 6817 success: '#4CAF50', 6818 warning: '#FB8C00' 6819 }, 6820 dark: { 6821 primary: '#2196F3', 6822 secondary: '#424242', 6823 accent: '#FF4081', 6824 error: '#FF5252', 6825 info: '#2196F3', 6826 success: '#4CAF50', 6827 warning: '#FB8C00' 6828 } 6829 } 6830 } 6831}; 6832// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/helpers.js 6833var helpers = __webpack_require__(6539); 6834// EXTERNAL MODULE: ./node_modules/vuetify/lib/services/service/index.js 6835var service = __webpack_require__(3931); 6836;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/presets/index.js 6837 6838const _excluded = ["preset"]; 6839// Preset 6840 // Utilities 6841 6842 6843 6844 6845class Presets extends service/* Service */.t { 6846 constructor(parentPreset, parent) { 6847 super(); // The default preset 6848 6849 const defaultPreset = (0,helpers/* mergeDeep */.Ee)({}, default_preset); // The user provided preset 6850 6851 const userPreset = parent.userPreset; // The user provided global preset 6852 6853 const _userPreset$preset = userPreset.preset, 6854 globalPreset = _userPreset$preset === void 0 ? {} : _userPreset$preset, 6855 preset = (0,objectWithoutProperties/* default */.Z)(userPreset, _excluded); 6856 if (globalPreset.preset != null) { 6857 (0,console/* consoleWarn */.Kd)('Global presets do not support the **preset** option, it can be safely omitted'); 6858 } 6859 parent.preset = (0,helpers/* mergeDeep */.Ee)((0,helpers/* mergeDeep */.Ee)(defaultPreset, globalPreset), preset); 6860 } 6861} 6862Presets.property = 'presets'; 6863;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/application/index.js 6864 6865// Extensions 6866 6867class Application extends service/* Service */.t { 6868 constructor() { 6869 super(...arguments); 6870 this.bar = 0; 6871 this.top = 0; 6872 this.left = 0; 6873 this.insetFooter = 0; 6874 this.right = 0; 6875 this.bottom = 0; 6876 this.footer = 0; 6877 this.application = { 6878 bar: {}, 6879 top: {}, 6880 left: {}, 6881 insetFooter: {}, 6882 right: {}, 6883 bottom: {}, 6884 footer: {} 6885 }; 6886 } 6887 register(uid, location, size) { 6888 this.application[location][uid] = size; 6889 this.update(location); 6890 } 6891 unregister(uid, location) { 6892 if (this.application[location][uid] == null) return; 6893 delete this.application[location][uid]; 6894 this.update(location); 6895 } 6896 update(location) { 6897 this[location] = Object.values(this.application[location]).reduce((acc, cur) => acc + cur, 0); 6898 } 6899} 6900Application.property = 'application'; 6901;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/breakpoint/index.js 6902// Extensions 6903 6904class Breakpoint extends service/* Service */.t { 6905 constructor(preset) { 6906 super(); // Public 6907 6908 this.xs = false; 6909 this.sm = false; 6910 this.md = false; 6911 this.lg = false;
6912 this.xl = false; 6913 this.xsOnly = false; 6914 this.smOnly = false; 6915 this.smAndDown = false; 6916 this.smAndUp = false; 6917 this.mdOnly = false; 6918 this.mdAndDown = false; 6919 this.mdAndUp = false; 6920 this.lgOnly = false; 6921 this.lgAndDown = false; 6922 this.lgAndUp = false; 6923 this.xlOnly = false; // Value is xs to match v2.x functionality 6924 6925 this.name = 'xs'; 6926 this.height = 0; 6927 this.width = 0; // TODO: Add functionality to detect this dynamically in v3 6928 // Value is true to match v2.x functionality 6929 6930 this.mobile = true; 6931 this.resizeTimeout = 0; 6932 const _preset$Breakpoint$pr = preset[Breakpoint.property], 6933 mobileBreakpoint = _preset$Breakpoint$pr.mobileBreakpoint, 6934 scrollBarWidth = _preset$Breakpoint$pr.scrollBarWidth, 6935 thresholds = _preset$Breakpoint$pr.thresholds; 6936 this.mobileBreakpoint = mobileBreakpoint; 6937 this.scrollBarWidth = scrollBarWidth; 6938 this.thresholds = thresholds; 6939 } 6940 init() { 6941 this.update(); 6942 /* istanbul ignore if */ 6943 6944 if (typeof window === 'undefined') return; 6945 window.addEventListener('resize', this.onResize.bind(this), { 6946 passive: true 6947 }); 6948 } 6949 /* eslint-disable-next-line max-statements */ 6950 6951 update() { 6952 let ssr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; 6953 const height = ssr ? 0 : this.getClientHeight(); 6954 const width = ssr ? 0 : this.getClientWidth(); 6955 const xs = width < this.thresholds.xs; 6956 const sm = width < this.thresholds.sm && !xs; 6957 const md = width < this.thresholds.md - this.scrollBarWidth && !(sm || xs); 6958 const lg = width < this.thresholds.lg - this.scrollBarWidth && !(md || sm || xs); 6959 const xl = width >= this.thresholds.lg - this.scrollBarWidth; 6960 this.height = height; 6961 this.width = width; 6962 this.xs = xs; 6963 this.sm = sm; 6964 this.md = md; 6965 this.lg = lg; 6966 this.xl = xl; 6967 this.xsOnly = xs; 6968 this.smOnly = sm; 6969 this.smAndDown = (xs || sm) && !(md || lg || xl); 6970 this.smAndUp = !xs && (sm || md || lg || xl); 6971 this.mdOnly = md; 6972 this.mdAndDown = (xs || sm || md) && !(lg || xl); 6973 this.mdAndUp = !(xs || sm) && (md || lg || xl); 6974 this.lgOnly = lg; 6975 this.lgAndDown = (xs || sm || md || lg) && !xl; 6976 this.lgAndUp = !(xs || sm || md) && (lg || xl); 6977 this.xlOnly = xl; 6978 switch (true) { 6979 case xs: 6980 this.name = 'xs'; 6981 break; 6982 case sm: 6983 this.name = 'sm'; 6984 break; 6985 case md: 6986 this.name = 'md'; 6987 break; 6988 case lg: 6989 this.name = 'lg'; 6990 break; 6991 default: 6992 this.name = 'xl'; 6993 break; 6994 } 6995 if (typeof this.mobileBreakpoint === 'number') { 6996 this.mobile = width < parseInt(this.mobileBreakpoint, 10); 6997 return; 6998 } 6999 const breakpoints = { 7000 xs: 0, 7001 sm: 1, 7002 md: 2, 7003 lg: 3, 7004 xl: 4 7005 }; 7006 const current = breakpoints[this.name]; 7007 const max = breakpoints[this.mobileBreakpoint]; 7008 this.mobile = current <= max; 7009 } 7010 onResize() { 7011 clearTimeout(this.resizeTimeout); // Added debounce to match what 7012 // v-resize used to do but was 7013 // removed due to a memory leak 7014 // https://github.com/vuetifyjs/vuetify/pull/2997 7015 7016 this.resizeTimeout = window.setTimeout(this.update.bind(this), 200); 7017 } // Cross-browser support as described in: 7018 // https://stackoverflow.com/questions/1248081 7019 7020 getClientWidth() { 7021 /* istanbul ignore if */ 7022 if (typeof document === 'undefined') return 0; // SSR 7023 7024 return Math.max(document.documentElement.clientWidth, window.innerWidth || 0); 7025 } 7026 getClientHeight() { 7027 /* istanbul ignore if */ 7028 if (typeof document === 'undefined') return 0; // SSR 7029 7030 return Math.max(document.documentElement.clientHeight, window.innerHeight || 0); 7031 } 7032} 7033Breakpoint.property = 'breakpoint'; 7034// EXTERNAL MODULE: ./node_modules/vuetify/lib/services/goto/index.js + 2 modules 7035var services_goto = __webpack_require__(60); 7036;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/mdi-svg.js 7037const icons = { 7038 complete: 'M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z', 7039 cancel: 'M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z', 7040 close: 'M19,6.41L17.59,5L12,10.59L6.41,5L5,6.41L10.59,12L5,17.59L6.41,19L12,13.41L17.59,19L19,17.59L13.41,12L19,6.41Z', 7041 delete: 'M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z', 7042 clear: 'M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z', 7043 success: 'M12 2C6.5 2 2 6.5 2 12S6.5 22 12 22 22 17.5 22 12 17.5 2 12 2M10 17L5 12L6.41 10.59L10 14.17L17.59 6.58L19 8L10 17Z', 7044 info: 'M13,9H11V7H13M13,17H11V11H13M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2ZM13,9H11V7H13M13,17H11V11H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z', 7045 warning: 'M13,13H11V7H13M13,17H11V15H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z', 7046 error: 'M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z',
7047 prev: 'M15.41,16.58L10.83,12L15.41,7.41L14,6L8,12L14,18L15.41,16.58Z', 7048 next: 'M8.59,16.58L13.17,12L8.59,7.41L10,6L16,12L10,18L8.59,16.58Z', 7049 checkboxOn: 'M10,17L5,12L6.41,10.58L10,14.17L17.59,6.58L19,8M19,3H5C3.89,3 3,3.89 3,5V19C3,20.1 3.9,21 5,21H19C20.1,21 21,20.1 21,19V5C21,3.89 20.1,3 19,3Z', 7050 checkboxOff: 'M19,3H5C3.89,3 3,3.89 3,5V19C3,20.1 3.9,21 5,21H19C20.1,21 21,20.1 21,19V5C21,3.89 20.1,3 19,3M19,5V19H5V5H19Z', 7051 checkboxIndeterminate: 'M17,13H7V11H17M19,3H5C3.89,3 3,3.89 3,5V19C3,20.1 3.9,21 5,21H19C20.1,21 21,20.1 21,19V5C21,3.89 20.1,3 19,3Z', 7052 delimiter: 'M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2Z', 7053 sort: 'M13,20H11V8L5.5,13.5L4.08,12.08L12,4.16L19.92,12.08L18.5,13.5L13,8V20Z', 7054 expand: 'M7.41,8.58L12,13.17L16.59,8.58L18,10L12,16L6,10L7.41,8.58Z', 7055 menu: 'M3,6H21V8H3V6M3,11H21V13H3V11M3,16H21V18H3V16Z', 7056 subgroup: 'M7,10L12,15L17,10H7Z', 7057 dropdown: 'M7,10L12,15L17,10H7Z', 7058 radioOn: 'M12,20C7.58,20 4,16.42 4,12C4,7.58 7.58,4 12,4C16.42,4 20,7.58 20,12C20,16.42 16.42,20 12,20M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2M12,7C9.24,7 7,9.24 7,12C7,14.76 9.24,17 12,17C14.76,17 17,14.76 17,12C17,9.24 14.76,7 12,7Z', 7059 radioOff: 'M12,20C7.58,20 4,16.42 4,12C4,7.58 7.58,4 12,4C16.42,4 20,7.58 20,12C20,16.42 16.42,20 12,20M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2Z', 7060 edit: 'M20.71,7.04C21.1,6.65 21.1,6 20.71,5.63L18.37,3.29C18,2.9 17.35,2.9 16.96,3.29L15.12,5.12L18.87,8.87M3,17.25V21H6.75L17.81,9.93L14.06,6.18L3,17.25Z', 7061 ratingEmpty: 'M12,15.39L8.24,17.66L9.23,13.38L5.91,10.5L10.29,10.13L12,6.09L13.71,10.13L18.09,10.5L14.77,13.38L15.76,17.66M22,9.24L14.81,8.63L12,2L9.19,8.63L2,9.24L7.45,13.97L5.82,21L12,17.27L18.18,21L16.54,13.97L22,9.24Z', 7062 ratingFull: 'M12,17.27L18.18,21L16.54,13.97L22,9.24L14.81,8.62L12,2L9.19,8.62L2,9.24L7.45,13.97L5.82,21L12,17.27Z', 7063 ratingHalf: 'M12,15.4V6.1L13.71,10.13L18.09,10.5L14.77,13.39L15.76,17.67M22,9.24L14.81,8.63L12,2L9.19,8.63L2,9.24L7.45,13.97L5.82,21L12,17.27L18.18,21L16.54,13.97L22,9.24Z', 7064 loading: 'M19,8L15,12H18C18,15.31 15.31,18 12,18C11,18 10.03,17.75 9.2,17.3L7.74,18.76C8.97,19.54 10.43,20 12,20C16.42,20 20,16.42 20,12H23M6,12C6,8.69 8.69,6 12,6C13,6 13.97,6.25 14.8,6.7L16.26,5.24C15.03,4.46 13.57,4 12,4C7.58,4 4,7.58 4,12H1L5,16L9,12', 7065 first: 'M18.41,16.59L13.82,12L18.41,7.41L17,6L11,12L17,18L18.41,16.59M6,6H8V18H6V6Z', 7066 last: 'M5.59,7.41L10.18,12L5.59,16.59L7,18L13,12L7,6L5.59,7.41M16,6H18V18H16V6Z', 7067 unfold: 'M12,18.17L8.83,15L7.42,16.41L12,21L16.59,16.41L15.17,15M12,5.83L15.17,9L16.58,7.59L12,3L7.41,7.59L8.83,9L12,5.83Z', 7068 file: 'M16.5,6V17.5C16.5,19.71 14.71,21.5 12.5,21.5C10.29,21.5 8.5,19.71 8.5,17.5V5C8.5,3.62 9.62,2.5 11,2.5C12.38,2.5 13.5,3.62 13.5,5V15.5C13.5,16.05 13.05,16.5 12.5,16.5C11.95,16.5 11.5,16.05 11.5,15.5V6H10V15.5C10,16.88 11.12,18 12.5,18C13.88,18 15,16.88 15,15.5V5C15,2.79 13.21,1 11,1C8.79,1 7,2.79 7,5V17.5C7,20.54 9.46,23 12.5,23C15.54,23 18,20.54 18,17.5V6H16.5Z', 7069 plus: 'M19,13H13V19H11V13H5V11H11V5H13V11H19V13Z', 7070 minus: 'M19,13H5V11H19V13Z' 7071}; 7072/* harmony default export */ var mdi_svg = (icons); 7073;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/md.js 7074const md_icons = { 7075 complete: 'check', 7076 cancel: 'cancel', 7077 close: 'close', 7078 delete: 'cancel', 7079 clear: 'clear', 7080 success: 'check_circle', 7081 info: 'info', 7082 warning: 'priority_high', 7083 error: 'warning', 7084 prev: 'chevron_left', 7085 next: 'chevron_right', 7086 checkboxOn: 'check_box', 7087 checkboxOff: 'check_box_outline_blank', 7088 checkboxIndeterminate: 'indeterminate_check_box', 7089 delimiter: 'fiber_manual_record', 7090 sort: 'arrow_upward', 7091 expand: 'keyboard_arrow_down', 7092 menu: 'menu', 7093 subgroup: 'arrow_drop_down', 7094 dropdown: 'arrow_drop_down', 7095 radioOn: 'radio_button_checked', 7096 radioOff: 'radio_button_unchecked', 7097 edit: 'edit', 7098 ratingEmpty: 'star_border', 7099 ratingFull: 'star', 7100 ratingHalf: 'star_half', 7101 loading: 'cached', 7102 first: 'first_page', 7103 last: 'last_page', 7104 unfold: 'unfold_more', 7105 file: 'attach_file', 7106 plus: 'add', 7107 minus: 'remove' 7108}; 7109/* harmony default export */ var md = (md_icons); 7110;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/mdi.js 7111const mdi_icons = { 7112 complete: 'mdi-check', 7113 cancel: 'mdi-close-circle', 7114 close: 'mdi-close', 7115 delete: 'mdi-close-circle', 7116 clear: 'mdi-close', 7117 success: 'mdi-check-circle', 7118 info: 'mdi-information', 7119 warning: 'mdi-exclamation', 7120 error: 'mdi-alert', 7121 prev: 'mdi-chevron-left', 7122 next: 'mdi-chevron-right', 7123 checkboxOn: 'mdi-checkbox-marked', 7124 checkboxOff: 'mdi-checkbox-blank-outline', 7125 checkboxIndeterminate: 'mdi-minus-box', 7126 delimiter: 'mdi-circle', 7127 sort: 'mdi-arrow-up', 7128 expand: 'mdi-chevron-down', 7129 menu: 'mdi-menu', 7130 subgroup: 'mdi-menu-down', 7131 dropdown: 'mdi-menu-down', 7132 radioOn: 'mdi-radiobox-marked', 7133 radioOff: 'mdi-radiobox-blank', 7134 edit: 'mdi-pencil', 7135 ratingEmpty: 'mdi-star-outline', 7136 ratingFull: 'mdi-star', 7137 ratingHalf: 'mdi-star-half-full', 7138 loading: 'mdi-cached', 7139 first: 'mdi-page-first', 7140 last: 'mdi-page-last', 7141 unfold: 'mdi-unfold-more-horizontal', 7142 file: 'mdi-paperclip', 7143 plus: 'mdi-plus', 7144 minus: 'mdi-minus' 7145}; 7146/* harmony default export */ var mdi = (mdi_icons); 7147;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/fa.js 7148const fa_icons = { 7149 complete: 'fas fa-check', 7150 cancel: 'fas fa-times-circle', 7151 close: 'fas fa-times', 7152 delete: 'fas fa-times-circle', 7153 clear: 'fas fa-times-circle', 7154 success: 'fas fa-check-circle', 7155 info: 'fas fa-info-circle', 7156 warning: 'fas fa-exclamation-circle', 7157 error: 'fas fa-exclamation-triangle', 7158 prev: 'fas fa-chevron-left', 7159 next: 'fas fa-chevron-right', 7160 checkboxOn: 'fas fa-check-square', 7161 checkboxOff: 'far fa-square', 7162 checkboxIndeterminate: 'fas fa-minus-square', 7163 delimiter: 'fas fa-circle', 7164 sort: 'fas fa-sort-up', 7165 expand: 'fas fa-chevron-down', 7166 menu: 'fas fa-bars', 7167 subgroup: 'fas fa-caret-down', 7168 dropdown: 'fas fa-caret-down', 7169 radioOn: 'far fa-dot-circle', 7170 radioOff: 'far fa-circle', 7171 edit: 'fas fa-edit', 7172 ratingEmpty: 'far fa-star', 7173 ratingFull: 'fas fa-star', 7174 ratingHalf: 'fas fa-star-half', 7175 loading: 'fas fa-sync', 7176 first: 'fas fa-step-backward', 7177 last: 'fas fa-step-forward', 7178 unfold: 'fas fa-arrows-alt-v', 7179 file: 'fas fa-paperclip', 7180 plus: 'fas fa-plus', 7181 minus: 'fas fa-minus' 7182}; 7183/* harmony default export */ var fa = (fa_icons); 7184;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/fa4.js 7185const fa4_icons = { 7186 complete: 'fa fa-check', 7187 cancel: 'fa fa-times-circle', 7188 close: 'fa fa-times', 7189 delete: 'fa fa-times-circle', 7190 clear: 'fa fa-times-circle', 7191 success: 'fa fa-check-circle', 7192 info: 'fa fa-info-circle', 7193 warning: 'fa fa-exclamation', 7194 error: 'fa fa-exclamation-triangle', 7195 prev: 'fa fa-chevron-left', 7196 next: 'fa fa-chevron-right', 7197 checkboxOn: 'fa fa-check-square', 7198 checkboxOff: 'fa fa-square-o', 7199 checkboxIndeterminate: 'fa fa-minus-square', 7200 delimiter: 'fa fa-circle', 7201 sort: 'fa fa-sort-up', 7202 expand: 'fa fa-chevron-down', 7203 menu: 'fa fa-bars', 7204 subgroup: 'fa fa-caret-down', 7205 dropdown: 'fa fa-caret-down', 7206 radioOn: 'fa fa-dot-circle-o', 7207 radioOff: 'fa fa-circle-o', 7208 edit: 'fa fa-pencil', 7209 ratingEmpty: 'fa fa-star-o', 7210 ratingFull: 'fa fa-star', 7211 ratingHalf: 'fa fa-star-half-o', 7212 loading: 'fa fa-refresh', 7213 first: 'fa fa-step-backward', 7214 last: 'fa fa-step-forward', 7215 unfold: 'fa fa-angle-double-down', 7216 file: 'fa fa-paperclip', 7217 plus: 'fa fa-plus', 7218 minus: 'fa fa-minus' 7219}; 7220/* harmony default export */ var fa4 = (fa4_icons); 7221// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.regexp.split.js 7222var es6_regexp_split = __webpack_require__(1876); 7223;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/fa-svg.js 7224 7225 7226function convertToComponentDeclarations(component, iconSet) { 7227 const result = {}; 7228 for (const key in iconSet) { 7229 result[key] = { 7230 component, 7231 props: { 7232 icon: iconSet[key].split(' fa-') 7233 } 7234 }; 7235 } 7236 return result; 7237} 7238/* harmony default export */ var fa_svg = (convertToComponentDeclarations('font-awesome-icon', fa)); 7239;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/presets/index.js 7240 7241 7242 7243 7244 7245 7246/* harmony default export */ var presets = (Object.freeze({ 7247 mdiSvg: mdi_svg, 7248 md: md, 7249 mdi: mdi, 7250 fa: fa, 7251 fa4: fa4, 7252 faSvg: fa_svg 7253})); 7254;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/icons/index.js 7255 7256// Extensions 7257 // Utilities 7258 7259 // Presets 7260 7261 7262class Icons extends service/* Service */.t { 7263 constructor(preset) { 7264 super(); 7265 const _preset$Icons$propert = preset[Icons.property], 7266 iconfont = _preset$Icons$propert.iconfont, 7267 values = _preset$Icons$propert.values, 7268 component = _preset$Icons$propert.component; 7269 this.component = component; 7270 this.iconfont = iconfont; 7271 this.values = (0,helpers/* mergeDeep */.Ee)(presets[iconfont], values); 7272 } 7273} 7274Icons.property = 'icons'; 7275// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.regexp.replace.js 7276var es6_regexp_replace = __webpack_require__(9357); 7277// EXTERNAL MODULE: ./node_modules/core-js/modules/es7.symbol.async-iterator.js 7278var es7_symbol_async_iterator = __webpack_require__(9665); 7279// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.symbol.js 7280var es6_symbol = __webpack_require__(5767); 7281;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/lang/index.js 7282 7283 7284 7285// Extensions 7286 // Utilities 7287 7288 7289 7290const LANG_PREFIX = '$vuetify.'; 7291const fallback = Symbol('Lang fallback'); 7292function getTranslation(locale, key) { 7293 let usingDefault = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
7294 let defaultLocale = arguments.length > 3 ? arguments[3] : undefined; 7295 const shortKey = key.replace(LANG_PREFIX, ''); 7296 let translation = (0,helpers/* getObjectValueByPath */.vO)(locale, shortKey, fallback); 7297 if (translation === fallback) { 7298 if (usingDefault) { 7299 (0,console/* consoleError */.N6)(`Translation key "${shortKey}" not found in fallback`); 7300 translation = key; 7301 } else { 7302 (0,console/* consoleWarn */.Kd)(`Translation key "${shortKey}" not found, falling back to default`); 7303 translation = getTranslation(defaultLocale, key, true, defaultLocale); 7304 } 7305 } 7306 return translation; 7307} 7308class Lang extends service/* Service */.t { 7309 constructor(preset) { 7310 super(); 7311 this.defaultLocale = 'en'; 7312 const _preset$Lang$property = preset[Lang.property], 7313 current = _preset$Lang$property.current, 7314 locales = _preset$Lang$property.locales, 7315 t = _preset$Lang$property.t; 7316 this.current = current; 7317 this.locales = locales; 7318 this.translator = t || this.defaultTranslator; 7319 } 7320 currentLocale(key) { 7321 const translation = this.locales[this.current]; 7322 const defaultLocale = this.locales[this.defaultLocale]; 7323 return getTranslation(translation, key, false, defaultLocale); 7324 } 7325 t(key) { 7326 for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 7327 params[_key - 1] = arguments[_key]; 7328 } 7329 if (!key.startsWith(LANG_PREFIX)) return this.replace(key, params); 7330 return this.translator(key, ...params); 7331 } 7332 defaultTranslator(key) { 7333 for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 7334 params[_key2 - 1] = arguments[_key2]; 7335 } 7336 return this.replace(this.currentLocale(key), params); 7337 } 7338 replace(str, params) { 7339 return str.replace(/\{(\d+)\}/g, (match, index) => { 7340 /* istanbul ignore next */ 7341 return String(params[+index]); 7342 }); 7343 } 7344} 7345Lang.property = 'lang'; 7346// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 5 modules 7347var slicedToArray = __webpack_require__(7625); 7348// EXTERNAL MODULE: ./node_modules/core-js/modules/es6.string.anchor.js 7349var es6_string_anchor = __webpack_require__(856); 7350// EXTERNAL MODULE: ./node_modules/vuetify/lib/util/colorUtils.js 7351var colorUtils = __webpack_require__(2787); 7352;// CONCATENATED MODULE: ./node_modules/vuetify/lib/util/color/transformSRGB.js 7353 // For converting XYZ to sRGB 7354 7355const srgbForwardMatrix = [[3.2406, -1.5372, -0.4986], [-0.9689, 1.8758, 0.0415], [0.0557, -0.2040, 1.0570]]; // Forward gamma adjust 7356 7357const srgbForwardTransform = C => C <= 0.0031308 ? C * 12.92 : 1.055 * C ** (1 / 2.4) - 0.055; // For converting sRGB to XYZ 7358 7359const srgbReverseMatrix = [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]]; // Reverse gamma adjust 7360 7361const srgbReverseTransform = C => C <= 0.04045 ? C / 12.92 : ((C + 0.055) / 1.055) ** 2.4; 7362function fromXYZ(xyz) { 7363 const rgb = Array(3); 7364 const transform = srgbForwardTransform; 7365 const matrix = srgbForwardMatrix; // Matrix transform, then gamma adjustment 7366 7367 for (let i = 0; i < 3; ++i) { 7368 rgb[i] = Math.round((0,helpers/* clamp */.uZ)(transform(matrix[i][0] * xyz[0] + matrix[i][1] * xyz[1] + matrix[i][2] * xyz[2])) * 255); 7369 } // Rescale back to [0, 255] 7370 7371 return (rgb[0] << 16) + (rgb[1] << 8) + (rgb[2] << 0); 7372} 7373function toXYZ(rgb) { 7374 const xyz = [0, 0, 0]; 7375 const transform = srgbReverseTransform; 7376 const matrix = srgbReverseMatrix; // Rescale from [0, 255] to [0, 1] then adjust sRGB gamma to linear RGB 7377 7378 const r = transform((rgb >> 16 & 0xff) / 255); 7379 const g = transform((rgb >> 8 & 0xff) / 255); 7380 const b = transform((rgb >> 0 & 0xff) / 255); // Matrix color space transform 7381 7382 for (let i = 0; i < 3; ++i) { 7383 xyz[i] = matrix[i][0] * r + matrix[i][1] * g + matrix[i][2] * b; 7384 } 7385 return xyz; 7386} 7387;// CONCATENATED MODULE: ./node_modules/vuetify/lib/util/color/transformCIELAB.js 7388const delta = 0.20689655172413793; // 6÷29 7389 7390const cielabForwardTransform = t => t > delta ** 3 ? Math.cbrt(t) : t / (3 * delta ** 2) + 4 / 29;
7391const cielabReverseTransform = t => t > delta ? t ** 3 : 3 * delta ** 2 * (t - 4 / 29); 7392function transformCIELAB_fromXYZ(xyz) { 7393 const transform = cielabForwardTransform; 7394 const transformedY = transform(xyz[1]); 7395 return [116 * transformedY - 16, 500 * (transform(xyz[0] / 0.95047) - transformedY), 200 * (transformedY - transform(xyz[2] / 1.08883))]; 7396} 7397function transformCIELAB_toXYZ(lab) { 7398 const transform = cielabReverseTransform; 7399 const Ln = (lab[0] + 16) / 116; 7400 return [transform(Ln + lab[1] / 500) * 0.95047, transform(Ln), transform(Ln - lab[2] / 200) * 1.08883]; 7401} 7402;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/theme/utils.js 7403 7404 7405 7406 7407 7408const utils_excluded = ["anchor"], 7409 _excluded2 = ["anchor"]; 7410 7411 7412 7413 7414function parse(theme) { 7415 let isItem = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 7416 let variations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; 7417 const anchor = theme.anchor, 7418 variant = (0,objectWithoutProperties/* default */.Z)(theme, utils_excluded); 7419 const colors = Object.keys(variant); 7420 const parsedTheme = {}; 7421 for (let i = 0; i < colors.length; ++i) { 7422 const name = colors[i]; 7423 const value = theme[name]; 7424 if (value == null) continue; 7425 if (!variations) { 7426 parsedTheme[name] = { 7427 base: (0,colorUtils/* intToHex */.I4)((0,colorUtils/* colorToInt */.jx)(value)) 7428 }; 7429 } else if (isItem) { 7430 /* istanbul ignore else */ 7431 if (name === 'base' || name.startsWith('lighten') || name.startsWith('darken')) { 7432 parsedTheme[name] = (0,colorUtils/* colorToHex */.hq)(value); 7433 } 7434 } else if (typeof value === 'object') { 7435 parsedTheme[name] = parse(value, true, variations); 7436 } else { 7437 parsedTheme[name] = genVariations(name, (0,colorUtils/* colorToInt */.jx)(value)); 7438 } 7439 } 7440 if (!isItem) { 7441 parsedTheme.anchor = anchor || parsedTheme.base || parsedTheme.primary.base; 7442 } 7443 return parsedTheme; 7444} 7445/** 7446 * Generate the CSS for a base color (.primary) 7447 */ 7448 7449const genBaseColor = (name, value) => { 7450 return ` 7451.v-application .${name} { 7452 background-color: ${value} !important; 7453 border-color: ${value} !important; 7454} 7455.v-application .${name}--text { 7456 color: ${value} !important; 7457 caret-color: ${value} !important; 7458}`; 7459}; 7460/** 7461 * Generate the CSS for a variant color (.primary.darken-2) 7462 */ 7463 7464const genVariantColor = (name, variant, value) => { 7465 const _variant$split = variant.split(/(\d)/, 2), 7466 _variant$split2 = (0,slicedToArray/* default */.Z)(_variant$split, 2), 7467 type = _variant$split2[0], 7468 n = _variant$split2[1]; 7469 return ` 7470.v-application .${name}.${type}-${n} { 7471 background-color: ${value} !important; 7472 border-color: ${value} !important; 7473} 7474.v-application .${name}--text.text--${type}-${n} { 7475 color: ${value} !important; 7476 caret-color: ${value} !important; 7477}`; 7478}; 7479const genColorVariableName = function genColorVariableName(name) { 7480 let variant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'base'; 7481 return `--v-${name}-${variant}`; 7482}; 7483const genColorVariable = function genColorVariable(name) { 7484 let variant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'base'; 7485 return `var(${genColorVariableName(name, variant)})`; 7486}; 7487function genStyles(theme) { 7488 let cssVar = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 7489 const anchor = theme.anchor, 7490 variant = (0,objectWithoutProperties/* default */.Z)(theme, _excluded2); 7491 const colors = Object.keys(variant); 7492 if (!colors.length) return ''; 7493 let variablesCss = ''; 7494 let css = ''; 7495 const aColor = cssVar ? genColorVariable('anchor') : anchor; 7496 css += `.v-application a { color: ${aColor}; }`; 7497 cssVar && (variablesCss += ` ${genColorVariableName('anchor')}: ${anchor};\n`); 7498 for (let i = 0; i < colors.length; ++i) { 7499 const name = colors[i]; 7500 const value = theme[name]; 7501 css += genBaseColor(name, cssVar ? genColorVariable(name) : value.base); 7502 cssVar && (variablesCss += ` ${genColorVariableName(name)}: ${value.base};\n`); 7503 const variants = (0,helpers/* keys */.XP)(value); 7504 for (let i = 0; i < variants.length; ++i) { 7505 const variant = variants[i]; 7506 const variantValue = value[variant]; 7507 if (variant === 'base') continue; 7508 css += genVariantColor(name, variant, cssVar ? genColorVariable(name, variant) : variantValue); 7509 cssVar && (variablesCss += ` ${genColorVariableName(name, variant)}: ${variantValue};\n`); 7510 } 7511 } 7512 if (cssVar) { 7513 variablesCss = `:root {\n${variablesCss}}\n\n`; 7514 } 7515 return variablesCss + css; 7516} 7517function genVariations(name, value) { 7518 const values = { 7519 base: (0,colorUtils/* intToHex */.I4)(value) 7520 }; 7521 for (let i = 5; i > 0; --i) { 7522 values[`lighten${i}`] = (0,colorUtils/* intToHex */.I4)(lighten(value, i)); 7523 } 7524 for (let i = 1; i <= 4; ++i) { 7525 values[`darken${i}`] = (0,colorUtils/* intToHex */.I4)(darken(value, i)); 7526 } 7527 return values; 7528} 7529function lighten(value, amount) { 7530 const lab = transformCIELAB_fromXYZ(toXYZ(value)); 7531 lab[0] = lab[0] + amount * 10; 7532 return fromXYZ(transformCIELAB_toXYZ(lab)); 7533} 7534function darken(value, amount) { 7535 const lab = transformCIELAB_fromXYZ(toXYZ(value)); 7536 lab[0] = lab[0] - amount * 10; 7537 return fromXYZ(transformCIELAB_toXYZ(lab)); 7538} 7539;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/theme/index.js 7540/* eslint-disable no-multi-spaces */ 7541// Extensions 7542 // Utilities 7543 7544 7545 // Types 7546 7547 7548class Theme extends service/* Service */.t { 7549 constructor(preset) { 7550 super(); 7551 this.disabled = false;
7552 this.isDark = null; 7553 this.unwatch = null; 7554 this.vueMeta = null; 7555 const _preset$Theme$propert = preset[Theme.property], 7556 dark = _preset$Theme$propert.dark, 7557 disable = _preset$Theme$propert.disable, 7558 options = _preset$Theme$propert.options, 7559 themes = _preset$Theme$propert.themes; 7560 this.dark = Boolean(dark); 7561 this.defaults = this.themes = themes; 7562 this.options = options; 7563 if (disable) { 7564 this.disabled = true; 7565 return; 7566 } 7567 this.themes = { 7568 dark: this.fillVariant(themes.dark, true), 7569 light: this.fillVariant(themes.light, false) 7570 }; 7571 } // When setting css, check for element and apply new values 7572 7573 /* eslint-disable-next-line accessor-pairs */ 7574 7575 set css(val) { 7576 if (this.vueMeta) { 7577 if (this.isVueMeta23) { 7578 this.applyVueMeta23(); 7579 } 7580 return; 7581 } 7582 this.checkOrCreateStyleElement() && (this.styleEl.innerHTML = val); 7583 } 7584 set dark(val) { 7585 const oldDark = this.isDark; 7586 this.isDark = val; // Only apply theme after dark 7587 // has already been set before 7588 7589 oldDark != null && this.applyTheme(); 7590 } 7591 get dark() { 7592 return Boolean(this.isDark); 7593 } // Apply current theme default 7594 // only called on client side 7595 7596 applyTheme() { 7597 if (this.disabled) return this.clearCss(); 7598 this.css = this.generatedStyles; 7599 } 7600 clearCss() { 7601 this.css = ''; 7602 } // Initialize theme for SSR and SPA 7603 // Attach to ssrContext head or 7604 // apply new theme to document 7605 7606 init(root, ssrContext) { 7607 if (this.disabled) return; 7608 /* istanbul ignore else */ 7609 7610 if (root.$meta) { 7611 this.initVueMeta(root); 7612 } else if (ssrContext) { 7613 this.initSSR(ssrContext); 7614 } 7615 this.initTheme(root); 7616 } // Allows for you to set target theme 7617 7618 setTheme(theme, value) { 7619 this.themes[theme] = Object.assign(this.themes[theme], value); 7620 this.applyTheme(); 7621 } // Reset theme defaults 7622 7623 resetThemes() { 7624 this.themes.light = Object.assign({}, this.defaults.light); 7625 this.themes.dark = Object.assign({}, this.defaults.dark); 7626 this.applyTheme(); 7627 } // Check for existence of style element 7628 7629 checkOrCreateStyleElement() { 7630 this.styleEl = document.getElementById('vuetify-theme-stylesheet'); 7631 /* istanbul ignore next */ 7632 7633 if (this.styleEl) return true; 7634 this.genStyleElement(); // If doesn't have it, create it 7635 7636 return Boolean(this.styleEl); 7637 } 7638 fillVariant() { 7639 let theme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 7640 let dark = arguments.length > 1 ? arguments[1] : undefined; 7641 const defaultTheme = this.themes[dark ? 'dark' : 'light']; 7642 return Object.assign({}, defaultTheme, theme); 7643 } // Generate the style element 7644 // if applicable 7645 7646 genStyleElement() { 7647 /* istanbul ignore if */ 7648 if (typeof document === 'undefined') return; 7649 /* istanbul ignore next */ 7650 7651 this.styleEl = document.createElement('style'); 7652 this.styleEl.type = 'text/css'; 7653 this.styleEl.id = 'vuetify-theme-stylesheet'; 7654 if (this.options.cspNonce) { 7655 this.styleEl.setAttribute('nonce', this.options.cspNonce); 7656 } 7657 document.head.appendChild(this.styleEl); 7658 } 7659 initVueMeta(root) { 7660 this.vueMeta = root.$meta(); 7661 if (this.isVueMeta23) { 7662 // vue-meta needs to apply after mounted() 7663 root.$nextTick(() => { 7664 this.applyVueMeta23(); 7665 }); 7666 return; 7667 } 7668 const metaKeyName = typeof this.vueMeta.getOptions === 'function' ? this.vueMeta.getOptions().keyName : 'metaInfo'; 7669 const metaInfo = root.$options[metaKeyName] || {}; 7670 root.$options[metaKeyName] = () => { 7671 metaInfo.style = metaInfo.style || []; 7672 const vuetifyStylesheet = metaInfo.style.find(s => s.id === 'vuetify-theme-stylesheet'); 7673 if (!vuetifyStylesheet) { 7674 metaInfo.style.push({ 7675 cssText: this.generatedStyles, 7676 type: 'text/css', 7677 id: 'vuetify-theme-stylesheet', 7678 nonce: (this.options || {}).cspNonce 7679 }); 7680 } else { 7681 vuetifyStylesheet.cssText = this.generatedStyles; 7682 } 7683 return metaInfo; 7684 }; 7685 } 7686 applyVueMeta23() { 7687 const _this$vueMeta$addApp = this.vueMeta.addApp('vuetify'), 7688 set = _this$vueMeta$addApp.set; 7689 set({ 7690 style: [{ 7691 cssText: this.generatedStyles, 7692 type: 'text/css', 7693 id: 'vuetify-theme-stylesheet', 7694 nonce: this.options.cspNonce 7695 }] 7696 }); 7697 } 7698 initSSR(ssrContext) { 7699 // SSR 7700 const nonce = this.options.cspNonce ? ` nonce="${this.options.cspNonce}"` : ''; 7701 ssrContext.head = ssrContext.head || ''; 7702 ssrContext.head += `<style type="text/css" id="vuetify-theme-stylesheet"${nonce}>${this.generatedStyles}</style>`; 7703 } 7704 initTheme(root) { 7705 // Only watch for reactivity on client side 7706 if (typeof document === 'undefined') return; // If we get here somehow, ensure 7707 // existing instance is removed 7708 7709 if (this.unwatch) { 7710 this.unwatch(); 7711 this.unwatch = null; 7712 } // TODO: Update to use RFC if merged 7713 // https://github.com/vuejs/rfcs/blob/advanced-reactivity-api/active-rfcs/0000-advanced-reactivity-api.md 7714 7715 root.$once('hook:created', () => { 7716 const obs = vue_esm/* default */.ZP.observable({ 7717 themes: this.themes 7718 }); 7719 this.unwatch = root.$watch(() => obs.themes, () => this.applyTheme(), { 7720 deep: true 7721 }); 7722 }); 7723 this.applyTheme(); 7724 }
7725 get currentTheme() { 7726 const target = this.dark ? 'dark' : 'light'; 7727 return this.themes[target]; 7728 } 7729 get generatedStyles() { 7730 const theme = this.parsedTheme; 7731 /* istanbul ignore next */ 7732 7733 const options = this.options || {}; 7734 let css; 7735 if (options.themeCache != null) { 7736 css = options.themeCache.get(theme); 7737 /* istanbul ignore if */ 7738 7739 if (css != null) return css; 7740 } 7741 css = genStyles(theme, options.customProperties); 7742 if (options.minifyTheme != null) { 7743 css = options.minifyTheme(css); 7744 } 7745 if (options.themeCache != null) { 7746 options.themeCache.set(theme, css); 7747 } 7748 return css; 7749 } 7750 get parsedTheme() { 7751 return parse(this.currentTheme || {}, undefined, (0,helpers/* getNestedValue */.qw)(this.options, ['variations'], true)); 7752 } // Is using v2.3 of vue-meta 7753 // https://github.com/nuxt/vue-meta/releases/tag/v2.3.0 7754 7755 get isVueMeta23() { 7756 return typeof this.vueMeta.addApp === 'function'; 7757 } 7758} 7759Theme.property = 'theme'; 7760;// CONCATENATED MODULE: ./node_modules/vuetify/lib/framework.js 7761 7762 // Services 7763 7764 7765class Vuetify { 7766 constructor() { 7767 let userPreset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 7768 this.framework = { 7769 isHydrating: false 7770 }; 7771 this.installed = []; 7772 this.preset = {}; 7773 this.userPreset = {}; 7774 this.userPreset = userPreset; 7775 this.use(Presets); 7776 this.use(Application); 7777 this.use(Breakpoint); 7778 this.use(services_goto/* Goto */.A); 7779 this.use(Icons); 7780 this.use(Lang); 7781 this.use(Theme); 7782 } // Called on the new vuetify instance 7783 // bootstrap in install beforeCreate 7784 // Exposes ssrContext if available 7785 7786 init(root, ssrContext) { 7787 this.installed.forEach(property => { 7788 const service = this.framework[property]; 7789 service.framework = this.framework; 7790 service.init(root, ssrContext); 7791 }); // rtl is not installed and 7792 // will never be called by 7793 // the init process 7794 7795 this.framework.rtl = Boolean(this.preset.rtl); 7796 } // Instantiate a VuetifyService 7797 7798 use(Service) { 7799 const property = Service.property; 7800 if (this.installed.includes(property)) return; // TODO maybe a specific type for arg 2? 7801 7802 this.framework[property] = new Service(this.preset, this); 7803 this.installed.push(property); 7804 } 7805} 7806Vuetify.install = install; 7807Vuetify.installed = false; 7808Vuetify.version = "2.7.1"; 7809Vuetify.config = { 7810 silent: false 7811}; 7812 7813/***/ }), 7814 7815/***/ 2994: 7816/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 7817 7818"use strict"; 7819/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 7820/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 7821/* harmony import */ var _delayable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2838); 7822/* harmony import */ var _toggleable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1796); 7823/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9547); 7824/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 7825/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9206); 7826 7827// Mixins 7828 7829 // Utilities 7830 7831 7832 7833 7834const baseMixins = (0,_util_mixins__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_delayable__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z, _toggleable__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z); 7835/* @vue/component */ 7836 7837/* harmony default export */ __webpack_exports__.Z = (baseMixins.extend({ 7838 name: 'activatable', 7839 props: { 7840 activator: { 7841 default: null, 7842 validator: val => { 7843 return ['string', 'object'].includes(typeof val); 7844 } 7845 }, 7846 disabled: Boolean, 7847 internalActivator: Boolean, 7848 openOnClick: { 7849 type: Boolean, 7850 default: true 7851 }, 7852 openOnHover: Boolean, 7853 openOnFocus: Boolean 7854 }, 7855 data: () => ({ 7856 // Do not use this directly, call getActivator() instead 7857 activatorElement: null, 7858 activatorNode: [], 7859 events: ['click', 'mouseenter', 'mouseleave', 'focus'], 7860 listeners: {} 7861 }), 7862 watch: { 7863 activator: 'resetActivator', 7864 openOnFocus: 'resetActivator', 7865 openOnHover: 'resetActivator' 7866 }, 7867 mounted() { 7868 const slotType = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .getSlotType */ .sp)(this, 'activator', true); 7869 if (slotType && ['v-slot', 'normal'].includes(slotType)) { 7870 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)(`The activator slot must be bound, try '<template v-slot:activator="{ on }"><v-btn v-on="on">'`, this); 7871 } 7872 this.addActivatorEvents(); 7873 }, 7874 beforeDestroy() { 7875 this.removeActivatorEvents(); 7876 }, 7877 methods: { 7878 addActivatorEvents() { 7879 if (!this.activator || this.disabled || !this.getActivator()) return; 7880 this.listeners = this.genActivatorListeners();
7881 const keys = Object.keys(this.listeners); 7882 for (const key of keys) { 7883 this.getActivator().addEventListener(key, this.listeners[key]); 7884 } 7885 }, 7886 genActivator() { 7887 const node = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .getSlot */ .z9)(this, 'activator', Object.assign(this.getValueProxy(), { 7888 on: this.genActivatorListeners(), 7889 attrs: this.genActivatorAttributes() 7890 })) || []; 7891 this.activatorNode = node; 7892 return node; 7893 }, 7894 genActivatorAttributes() { 7895 return { 7896 role: this.openOnClick && !this.openOnHover ? 'button' : undefined, 7897 'aria-haspopup': true, 7898 'aria-expanded': String(this.isActive) 7899 }; 7900 }, 7901 genActivatorListeners() { 7902 if (this.disabled) return {}; 7903 const listeners = {}; 7904 if (this.openOnHover) { 7905 listeners.mouseenter = e => { 7906 this.getActivator(e); 7907 this.runDelay('open'); 7908 }; 7909 listeners.mouseleave = e => { 7910 this.getActivator(e); 7911 this.runDelay('close'); 7912 }; 7913 } else if (this.openOnClick) { 7914 listeners.click = e => { 7915 const activator = this.getActivator(e); 7916 if (activator) activator.focus(); 7917 e.stopPropagation(); 7918 this.isActive = !this.isActive; 7919 }; 7920 } 7921 if (this.openOnFocus) { 7922 listeners.focus = e => { 7923 this.getActivator(e); 7924 e.stopPropagation(); 7925 this.isActive = !this.isActive; 7926 }; 7927 } 7928 return listeners; 7929 }, 7930 getActivator(e) { 7931 // If we've already fetched the activator, re-use 7932 if (this.activatorElement) return this.activatorElement; 7933 let activator = null; 7934 if (this.activator) { 7935 const target = this.internalActivator ? this.$el : document; 7936 if (typeof this.activator === 'string') { 7937 // Selector 7938 activator = target.querySelector(this.activator); 7939 } else if (this.activator.$el) { 7940 // Component (ref) 7941 activator = this.activator.$el; 7942 } else { 7943 // HTMLElement | Element 7944 activator = this.activator; 7945 } 7946 } else if (this.activatorNode.length === 1 || this.activatorNode.length && !e) { 7947 // Use the contents of the activator slot 7948 // There's either only one element in it or we 7949 // don't have a click event to use as a last resort 7950 const vm = this.activatorNode[0].componentInstance; 7951 if (vm && vm.$options.mixins && 7952 // Activatable is indirectly used via Menuable 7953 vm.$options.mixins.some(m => m.options && ['activatable', 'menuable'].includes(m.options.name))) { 7954 // Activator is actually another activatible component, use its activator (#8846) 7955 activator = vm.getActivator(); 7956 } else { 7957 activator = this.activatorNode[0].elm; 7958 } 7959 } else if (e) { 7960 // Activated by a click or focus event 7961 activator = e.currentTarget || e.target; 7962 } // The activator should only be a valid element (Ignore comments and text nodes) 7963 7964 this.activatorElement = (activator === null || activator === void 0 ? void 0 : activator.nodeType) === Node.ELEMENT_NODE ? activator : null; 7965 return this.activatorElement; 7966 }, 7967 getContentSlot() { 7968 return (0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .getSlot */ .z9)(this, 'default', this.getValueProxy(), true); 7969 }, 7970 getValueProxy() { 7971 const self = this; 7972 return { 7973 get value() { 7974 return self.isActive; 7975 }, 7976 set value(isActive) { 7977 self.isActive = isActive; 7978 } 7979 }; 7980 }, 7981 removeActivatorEvents() { 7982 if (!this.activator || !this.activatorElement) return; 7983 const keys = Object.keys(this.listeners); 7984 for (const key of keys) { 7985 this.activatorElement.removeEventListener(key, this.listeners[key]); 7986 } 7987 this.listeners = {}; 7988 }, 7989 resetActivator() { 7990 this.removeActivatorEvents(); 7991 this.activatorElement = null; 7992 this.getActivator(); 7993 this.addActivatorEvents(); 7994 } 7995 } 7996})); 7997 7998/***/ }), 7999 8000/***/ 4796: 8001/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8002 8003"use strict"; 8004/* harmony export */ __webpack_require__.d(__webpack_exports__, { 8005/* harmony export */ Z: function() { return /* binding */ applicationable; } 8006/* harmony export */ }); 8007/* harmony import */ var _positionable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4287); 8008/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9547); 8009 // Util 8010 8011 8012function applicationable(value) { 8013 let events = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; 8014 /* @vue/component */ 8015 return (0,_util_mixins__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)((0,_positionable__WEBPACK_IMPORTED_MODULE_1__/* .factory */ .d)(['absolute', 'fixed'])).extend({ 8016 name: 'applicationable', 8017 props: { 8018 app: Boolean 8019 }, 8020 computed: { 8021 applicationProperty() { 8022 return value; 8023 } 8024 }, 8025 watch: { 8026 // If previous value was app 8027 // reset the provided prop 8028 app(x, prev) { 8029 prev ? this.removeApplication(true) : this.callUpdate(); 8030 }, 8031 applicationProperty(newVal, oldVal) { 8032 this.$vuetify.application.unregister(this._uid, oldVal); 8033 } 8034 }, 8035 activated() { 8036 this.callUpdate(); 8037 }, 8038 created() { 8039 for (let i = 0, length = events.length; i < length; i++) { 8040 this.$watch(events[i], this.callUpdate); 8041 } 8042 this.callUpdate(); 8043 }, 8044 mounted() { 8045 this.callUpdate(); 8046 }, 8047 deactivated() { 8048 this.removeApplication(); 8049 }, 8050 destroyed() { 8051 this.removeApplication(); 8052 }, 8053 methods: { 8054 callUpdate() { 8055 if (!this.app) return; 8056 this.$vuetify.application.register(this._uid, this.applicationProperty, this.updateApplication()); 8057 }, 8058 removeApplication() { 8059 let force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
8060 if (!force && !this.app) return; 8061 this.$vuetify.application.unregister(this._uid, this.applicationProperty); 8062 }, 8063 updateApplication: () => 0 8064 } 8065 }); 8066} 8067 8068/***/ }), 8069 8070/***/ 1679: 8071/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8072 8073"use strict"; 8074/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 8075 8076/** 8077 * This mixin provides `attrs$` and `listeners$` to work around 8078 * vue bug https://github.com/vuejs/vue/issues/10115 8079 */ 8080 8081function makeWatcher(property) { 8082 return function (val, oldVal) { 8083 for (const attr in oldVal) { 8084 if (!Object.prototype.hasOwnProperty.call(val, attr)) { 8085 this.$delete(this.$data[property], attr); 8086 } 8087 } 8088 for (const attr in val) { 8089 this.$set(this.$data[property], attr, val[attr]); 8090 } 8091 }; 8092} 8093/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 8094 data: () => ({ 8095 attrs$: {}, 8096 listeners$: {} 8097 }), 8098 created() { 8099 // Work around unwanted re-renders: https://github.com/vuejs/vue/issues/10115 8100 // Make sure to use `attrs$` instead of `$attrs` (confusing right?) 8101 this.$watch('$attrs', makeWatcher('attrs$'), { 8102 immediate: true 8103 }); 8104 this.$watch('$listeners', makeWatcher('listeners$'), { 8105 immediate: true 8106 }); 8107 } 8108})); 8109 8110/***/ }), 8111 8112/***/ 2568: 8113/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8114 8115"use strict"; 8116/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9206); 8117/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 8118// Utilities 8119 // Types 8120 8121 8122/** 8123 * Bootable 8124 * @mixin 8125 * 8126 * Used to add lazy content functionality to components 8127 * Looks for change in "isActive" to automatically boot 8128 * Otherwise can be set manually 8129 */ 8130
8131/* @vue/component */ 8132 8133/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend().extend({ 8134 name: 'bootable', 8135 props: { 8136 eager: Boolean 8137 }, 8138 data: () => ({ 8139 isBooted: false 8140 }), 8141 computed: { 8142 hasContent() { 8143 return this.isBooted || this.eager || this.isActive; 8144 } 8145 }, 8146 watch: { 8147 isActive() { 8148 this.isBooted = true; 8149 } 8150 }, 8151 created() { 8152 /* istanbul ignore next */ 8153 if ('lazy' in this.$attrs) { 8154 (0,_util_console__WEBPACK_IMPORTED_MODULE_1__/* .removed */ .Jk)('lazy', this); 8155 } 8156 }, 8157 methods: { 8158 showLazyContent(content) { 8159 return this.hasContent && content ? content() : [this.$createElement()]; 8160 } 8161 } 8162})); 8163 8164/***/ }), 8165 8166/***/ 8390: 8167/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8168 8169"use strict"; 8170/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 8171/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 8172/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6108); 8173/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1__); 8174/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1876); 8175/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2__); 8176/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_slicedToArray_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(7625); 8177/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1180); 8178/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(538); 8179/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9206); 8180/* harmony import */ var _util_colorUtils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2787); 8181 8182 8183 8184 8185 8186function 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; } 8187function _objectSpread(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) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(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; } 8188 8189 8190 8191/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .ZP.extend({ 8192 name: 'colorable', 8193 props: { 8194 color: String 8195 }, 8196 methods: { 8197 setBackgroundColor(color) { 8198 let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 8199 if (typeof data.style === 'string') { 8200 // istanbul ignore next 8201 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)('style must be an object', this); // istanbul ignore next 8202 8203 return data; 8204 } 8205 if (typeof data.class === 'string') { 8206 // istanbul ignore next 8207 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)('class must be an object', this); // istanbul ignore next 8208 8209 return data; 8210 } 8211 if ((0,_util_colorUtils__WEBPACK_IMPORTED_MODULE_6__/* .isCssColor */ .NA)(color)) { 8212 data.style = _objectSpread(_objectSpread({}, data.style), {}, { 8213 'background-color': `${color}`, 8214 'border-color': `${color}` 8215 }); 8216 } else if (color) { 8217 data.class = _objectSpread(_objectSpread({}, data.class), {}, { 8218 [color]: true 8219 }); 8220 } 8221 return data; 8222 }, 8223 setTextColor(color) { 8224 let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 8225 if (typeof data.style === 'string') { 8226 // istanbul ignore next 8227 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)('style must be an object', this); // istanbul ignore next 8228 8229 return data; 8230 } 8231 if (typeof data.class === 'string') { 8232 // istanbul ignore next 8233 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)('class must be an object', this); // istanbul ignore next 8234 8235 return data; 8236 } 8237 if ((0,_util_colorUtils__WEBPACK_IMPORTED_MODULE_6__/* .isCssColor */ .NA)(color)) { 8238 data.style = _objectSpread(_objectSpread({}, data.style), {}, { 8239 color: `${color}`, 8240 'caret-color': `${color}` 8241 }); 8242 } else if (color) { 8243 const _color$toString$trim$ = color.toString().trim().split(' ', 2), 8244 _color$toString$trim$2 = (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_slicedToArray_js__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)(_color$toString$trim$, 2), 8245 colorName = _color$toString$trim$2[0], 8246 colorModifier = _color$toString$trim$2[1]; 8247 data.class = _objectSpread(_objectSpread({}, data.class), {}, { 8248 [colorName + '--text']: true 8249 }); 8250 if (colorModifier) { 8251 data.class['text--' + colorModifier] = true; 8252 } 8253 } 8254 return data; 8255 } 8256 } 8257})); 8258 8259/***/ }), 8260 8261/***/ 2838: 8262/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8263 8264"use strict"; 8265/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 8266 8267/** 8268 * Delayable 8269 * 8270 * @mixin 8271 * 8272 * Changes the open or close delay time for elements 8273 */ 8274
8275/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend().extend({ 8276 name: 'delayable', 8277 props: { 8278 openDelay: { 8279 type: [Number, String], 8280 default: 0 8281 }, 8282 closeDelay: { 8283 type: [Number, String], 8284 default: 0 8285 } 8286 }, 8287 data: () => ({ 8288 openTimeout: undefined, 8289 closeTimeout: undefined 8290 }), 8291 methods: { 8292 /** 8293 * Clear any pending delay timers from executing 8294 */ 8295 clearDelay() { 8296 clearTimeout(this.openTimeout); 8297 clearTimeout(this.closeTimeout); 8298 }, 8299 /** 8300 * Runs callback after a specified delay 8301 */ 8302 runDelay(type, cb) { 8303 this.clearDelay(); 8304 const delay = parseInt(this[`${type}Delay`], 10); 8305 this[`${type}Timeout`] = setTimeout(cb || (() => { 8306 this.isActive = { 8307 open: true, 8308 close: false 8309 }[type]; 8310 }), delay); 8311 } 8312 } 8313})); 8314 8315/***/ }), 8316 8317/***/ 1511: 8318/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8319 8320"use strict"; 8321/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9547); 8322 8323function searchChildren(children) { 8324 const results = []; 8325 for (let index = 0; index < children.length; index++) { 8326 const child = children[index]; 8327 if (child.isActive && child.isDependent) { 8328 results.push(child); 8329 } else { 8330 results.push(...searchChildren(child.$children)); 8331 } 8332 } 8333 return results; 8334} 8335/* @vue/component */ 8336 8337/* harmony default export */ __webpack_exports__.Z = ((0,_util_mixins__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)().extend({ 8338 name: 'dependent', 8339 data() { 8340 return { 8341 closeDependents: true, 8342 isActive: false, 8343 isDependent: true 8344 }; 8345 }, 8346 watch: { 8347 isActive(val) { 8348 if (val) return; 8349 const openDependents = this.getOpenDependents(); 8350 for (let index = 0; index < openDependents.length; index++) { 8351 openDependents[index].isActive = false; 8352 } 8353 } 8354 }, 8355 methods: { 8356 getOpenDependents() { 8357 if (this.closeDependents) return searchChildren(this.$children); 8358 return []; 8359 }, 8360 getOpenDependentElements() { 8361 const result = []; 8362 const openDependents = this.getOpenDependents(); 8363 for (let index = 0; index < openDependents.length; index++) { 8364 result.push(...openDependents[index].getClickableDependentElements()); 8365 } 8366 return result; 8367 }, 8368 getClickableDependentElements() { 8369 const result = [this.$el]; 8370 if (this.$refs.content) result.push(this.$refs.content); 8371 if (this.overlay) result.push(this.overlay.$el); 8372 result.push(...this.getOpenDependentElements()); 8373 return result; 8374 } 8375 } 8376})); 8377 8378/***/ }), 8379 8380/***/ 9865: 8381/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8382 8383"use strict"; 8384/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 8385/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 8386/* harmony import */ var _bootable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2568); 8387/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6539); 8388/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9547); 8389/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9206); 8390 8391// Mixins 8392 // Utilities 8393 8394 8395 8396 8397function validateAttachTarget(val) { 8398 const type = typeof val; 8399 if (type === 'boolean' || type === 'string') return true; 8400 return val.nodeType === Node.ELEMENT_NODE; 8401} 8402function removeActivator(activator) { 8403 activator.forEach(node => { 8404 node.elm && node.elm.parentNode && node.elm.parentNode.removeChild(node.elm); 8405 }); 8406} 8407/* @vue/component */ 8408 8409/* harmony default export */ __webpack_exports__.Z = ((0,_util_mixins__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(_bootable__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z).extend({ 8410 name: 'detachable', 8411 props: { 8412 attach: { 8413 default: false, 8414 validator: validateAttachTarget 8415 }, 8416 contentClass: { 8417 type: String, 8418 default: '' 8419 } 8420 }, 8421 data: () => ({ 8422 activatorNode: null, 8423 hasDetached: false 8424 }), 8425 watch: { 8426 attach() { 8427 this.hasDetached = false;
8428 this.initDetach(); 8429 }, 8430 hasContent() { 8431 this.$nextTick(this.initDetach); 8432 } 8433 }, 8434 beforeMount() { 8435 this.$nextTick(() => { 8436 if (this.activatorNode) { 8437 const activator = Array.isArray(this.activatorNode) ? this.activatorNode : [this.activatorNode]; 8438 activator.forEach(node => { 8439 if (!node.elm) return; 8440 if (!this.$el.parentNode) return; 8441 const target = this.$el === this.$el.parentNode.firstChild ? this.$el : this.$el.nextSibling; 8442 this.$el.parentNode.insertBefore(node.elm, target); 8443 }); 8444 } 8445 }); 8446 }, 8447 mounted() { 8448 this.hasContent && this.initDetach(); 8449 }, 8450 deactivated() { 8451 this.isActive = false; 8452 }, 8453 beforeDestroy() { 8454 if (this.$refs.content && this.$refs.content.parentNode) { 8455 this.$refs.content.parentNode.removeChild(this.$refs.content); 8456 } 8457 }, 8458 destroyed() { 8459 if (this.activatorNode) { 8460 const activator = Array.isArray(this.activatorNode) ? this.activatorNode : [this.activatorNode]; 8461 if (this.$el.isConnected) { 8462 // Component has been destroyed but the element still exists, we must be in a transition 8463 // Wait for the transition to finish before cleaning up the detached activator 8464 const observer = new MutationObserver(list => { 8465 if (list.some(record => Array.from(record.removedNodes).includes(this.$el))) { 8466 observer.disconnect(); 8467 removeActivator(activator); 8468 } 8469 }); 8470 observer.observe(this.$el.parentNode, { 8471 subtree: false, 8472 childList: true 8473 }); 8474 } else { 8475 removeActivator(activator); 8476 } 8477 } 8478 }, 8479 methods: { 8480 getScopeIdAttrs() { 8481 const scopeId = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_3__/* .getObjectValueByPath */ .vO)(this.$vnode, 'context.$options._scopeId'); 8482 return scopeId && { 8483 [scopeId]: '' 8484 }; 8485 }, 8486 initDetach() { 8487 if (this._isDestroyed || !this.$refs.content || this.hasDetached || 8488 // Leave menu in place if attached 8489 // and dev has not changed target 8490 this.attach === '' || 8491 // If used as a boolean prop (<v-menu attach>) 8492 this.attach === true || 8493 // If bound to a boolean (<v-menu :attach="true">) 8494 this.attach === 'attach' // If bound as boolean prop in pug (v-menu(attach)) 8495 ) return; 8496 let target; 8497 if (this.attach === false) { 8498 // Default, detach to app 8499 target = document.querySelector('[data-app]'); 8500 } else if (typeof this.attach === 'string') { 8501 // CSS selector 8502 target = document.querySelector(this.attach); 8503 } else { 8504 // DOM Element 8505 target = this.attach; 8506 } 8507 if (!target) { 8508 (0,_util_console__WEBPACK_IMPORTED_MODULE_4__/* .consoleWarn */ .Kd)(`Unable to locate target ${this.attach || '[data-app]'}`, this); 8509 return; 8510 } 8511 target.appendChild(this.$refs.content); 8512 this.hasDetached = true; 8513 } 8514 } 8515})); 8516 8517/***/ }), 8518 8519/***/ 3657: 8520/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8521 8522"use strict"; 8523/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 8524 8525/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 8526 name: 'elevatable', 8527 props: { 8528 elevation: [Number, String] 8529 }, 8530 computed: { 8531 computedElevation() { 8532 return this.elevation; 8533 }, 8534 elevationClasses() { 8535 const elevation = this.computedElevation; 8536 if (elevation == null) return {}; 8537 if (isNaN(parseInt(elevation))) return {}; 8538 return { 8539 [`elevation-${this.elevation}`]: true 8540 }; 8541 } 8542 } 8543})); 8544 8545/***/ }), 8546 8547/***/ 1801: 8548/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8549 8550"use strict"; 8551/* harmony export */ __webpack_require__.d(__webpack_exports__, { 8552/* harmony export */ d: function() { return /* binding */ factory; } 8553/* harmony export */ }); 8554/* harmony import */ var _registrable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(474); 8555// Mixins 8556 8557function factory(namespace, child, parent) { 8558 return (0,_registrable__WEBPACK_IMPORTED_MODULE_0__/* .inject */ .f)(namespace, child, parent).extend({ 8559 name: 'groupable', 8560 props: { 8561 activeClass: { 8562 type: String, 8563 default() { 8564 if (!this[namespace]) return undefined; 8565 return this[namespace].activeClass; 8566 } 8567 }, 8568 disabled: Boolean 8569 }, 8570 data() { 8571 return { 8572 isActive: false 8573 }; 8574 }, 8575 computed: { 8576 groupClasses() { 8577 if (!this.activeClass) return {}; 8578 return { 8579 [this.activeClass]: this.isActive 8580 }; 8581 } 8582 }, 8583 created() { 8584 this[namespace] && this[namespace].register(this); 8585 }, 8586 beforeDestroy() { 8587 this[namespace] && this[namespace].unregister(this); 8588 }, 8589 methods: { 8590 toggle(e) { 8591 if (this.disabled && e) { 8592 // Prevent keyboard actions 8593 // from children elements 8594 // within disabled tabs 8595 e.preventDefault(); 8596 return; 8597 } 8598 this.$emit('change'); 8599 } 8600 } 8601 }); 8602} 8603/* eslint-disable-next-line @typescript-eslint/no-redeclare */ 8604 8605const Groupable = factory('itemGroup'); 8606/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (Groupable))); 8607 8608/***/ }), 8609 8610/***/ 5419: 8611/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8612 8613"use strict"; 8614 8615// EXPORTS 8616__webpack_require__.d(__webpack_exports__, { 8617 Z: function() { return /* binding */ loadable; } 8618}); 8619 8620// EXTERNAL MODULE: ./node_modules/vue/dist/vue.esm.js 8621var vue_esm = __webpack_require__(538); 8622// EXTERNAL MODULE: ./node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.js + 1 modules 8623var VProgressLinear = __webpack_require__(9393); 8624;// CONCATENATED MODULE: ./node_modules/vuetify/lib/components/VProgressLinear/index.js 8625 8626 8627/* harmony default export */ var components_VProgressLinear = (VProgressLinear/* default */.Z); 8628;// CONCATENATED MODULE: ./node_modules/vuetify/lib/mixins/loadable/index.js 8629 8630 8631/** 8632 * Loadable 8633 * 8634 * @mixin 8635 * 8636 * Used to add linear progress bar to components 8637 * Can use a default bar with a specific color 8638 * or designate a custom progress linear bar 8639 */ 8640 8641/* @vue/component */ 8642 8643/* harmony default export */ var loadable = (vue_esm/* default */.ZP.extend().extend({ 8644 name: 'loadable', 8645 props: { 8646 loading: { 8647 type: [Boolean, String], 8648 default: false 8649 }, 8650 loaderHeight: { 8651 type: [Number, String], 8652 default: 2 8653 } 8654 }, 8655 methods: { 8656 genProgress() { 8657 if (this.loading === false) return null; 8658 return this.$slots.progress || this.$createElement(components_VProgressLinear, { 8659 props: { 8660 absolute: true, 8661 color: this.loading === true || this.loading === '' ? this.color || 'primary' : this.loading, 8662 height: this.loaderHeight, 8663 indeterminate: true 8664 } 8665 }); 8666 } 8667 } 8668})); 8669 8670/***/ }), 8671 8672/***/ 8888: 8673/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8674 8675"use strict"; 8676/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6539); 8677/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 8678// Helpers 8679 // Types 8680 8681 8682/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 8683 name: 'measurable', 8684 props: { 8685 height: [Number, String], 8686 maxHeight: [Number, String], 8687 maxWidth: [Number, String], 8688 minHeight: [Number, String], 8689 minWidth: [Number, String], 8690 width: [Number, String] 8691 }, 8692 computed: { 8693 measurableStyles() { 8694 const styles = {}; 8695 const height = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.height); 8696 const minHeight = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.minHeight); 8697 const minWidth = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.minWidth); 8698 const maxHeight = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.maxHeight); 8699 const maxWidth = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.maxWidth); 8700 const width = (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .convertToUnit */ .kb)(this.width); 8701 if (height) styles.height = height; 8702 if (minHeight) styles.minHeight = minHeight; 8703 if (minWidth) styles.minWidth = minWidth; 8704 if (maxHeight) styles.maxHeight = maxHeight; 8705 if (maxWidth) styles.maxWidth = maxWidth; 8706 if (width) styles.width = width; 8707 return styles; 8708 } 8709 } 8710})); 8711 8712/***/ }), 8713 8714/***/ 7403: 8715/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 8716 8717"use strict"; 8718/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 8719/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 8720/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1180); 8721/* harmony import */ var _stackable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6250); 8722/* harmony import */ var _positionable__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4287); 8723/* harmony import */ var _activatable__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2994); 8724/* harmony import */ var _detachable__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9865); 8725/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9547); 8726/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6539); 8727 8728 8729function 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; } 8730function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
8730 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(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; } 8731// Mixins 8732 8733 8734 8735 // Utilities 8736 8737 8738 8739const baseMixins = (0,_util_mixins__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(_stackable__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z, (0,_positionable__WEBPACK_IMPORTED_MODULE_4__/* .factory */ .d)(['top', 'right', 'bottom', 'left', 'absolute']), _activatable__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z, _detachable__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z); 8740/* @vue/component */ 8741 8742/* harmony default export */ __webpack_exports__.Z = (baseMixins.extend().extend({ 8743 name: 'menuable', 8744 props: { 8745 allowOverflow: Boolean, 8746 light: Boolean, 8747 dark: Boolean, 8748 maxWidth: { 8749 type: [Number, String], 8750 default: 'auto' 8751 }, 8752 minWidth: [Number, String], 8753 nudgeBottom: { 8754 type: [Number, String], 8755 default: 0 8756 }, 8757 nudgeLeft: { 8758 type: [Number, String], 8759 default: 0 8760 }, 8761 nudgeRight: { 8762 type: [Number, String], 8763 default: 0 8764 }, 8765 nudgeTop: { 8766 type: [Number, String], 8767 default: 0 8768 }, 8769 nudgeWidth: { 8770 type: [Number, String], 8771 default: 0 8772 }, 8773 offsetOverflow: Boolean, 8774 positionX: { 8775 type: Number, 8776 default: null 8777 }, 8778 positionY: { 8779 type: Number, 8780 default: null 8781 }, 8782 zIndex: { 8783 type: [Number, String], 8784 default: null 8785 } 8786 }, 8787 data: () => ({ 8788 activatorNode: [], 8789 absoluteX: 0, 8790 absoluteY: 0, 8791 activatedBy: null, 8792 activatorFixed: false, 8793 dimensions: { 8794 activator: { 8795 top: 0, 8796 left: 0, 8797 bottom: 0, 8798 right: 0, 8799 width: 0, 8800 height: 0, 8801 offsetTop: 0, 8802 scrollHeight: 0, 8803 offsetLeft: 0 8804 }, 8805 content: { 8806 top: 0, 8807 left: 0, 8808 bottom: 0, 8809 right: 0, 8810 width: 0, 8811 height: 0, 8812 offsetTop: 0, 8813 scrollHeight: 0 8814 } 8815 }, 8816 relativeYOffset: 0, 8817 hasJustFocused: false, 8818 hasWindow: false, 8819 inputActivator: false, 8820 isContentActive: false, 8821 pageWidth: 0, 8822 pageYOffset: 0, 8823 stackClass: 'v-menu__content--active', 8824 stackMinZIndex: 6 8825 }), 8826 computed: { 8827 computedLeft() { 8828 const a = this.dimensions.activator; 8829 const c = this.dimensions.content; 8830 const activatorLeft = (this.attach !== false ? a.offsetLeft : a.left) || 0; 8831 const minWidth = Math.max(a.width, c.width); 8832 let left = 0; 8833 left += activatorLeft; 8834 if (this.left || this.$vuetify.rtl && !this.right) left -= minWidth - a.width; 8835 if (this.offsetX) { 8836 const maxWidth = isNaN(Number(this.maxWidth)) ? a.width : Math.min(a.width, Number(this.maxWidth)); 8837 left += this.left ? -maxWidth : a.width; 8838 } 8839 if (this.nudgeLeft) left -= parseInt(this.nudgeLeft); 8840 if (this.nudgeRight) left += parseInt(this.nudgeRight); 8841 return left; 8842 }, 8843 computedTop() { 8844 const a = this.dimensions.activator; 8845 const c = this.dimensions.content; 8846 let top = 0; 8847 if (this.top) top += a.height - c.height; 8848 if (this.attach !== false) top += a.offsetTop;else top += a.top + this.pageYOffset; 8849 if (this.offsetY) top += this.top ? -a.height : a.height; 8850 if (this.nudgeTop) top -= parseInt(this.nudgeTop); 8851 if (this.nudgeBottom) top += parseInt(this.nudgeBottom); 8852 return top; 8853 }, 8854 hasActivator() { 8855 return !!this.$slots.activator || !!this.$scopedSlots.activator || !!this.activator || !!this.inputActivator; 8856 }, 8857 absoluteYOffset() { 8858 return this.pageYOffset - this.relativeYOffset; 8859 } 8860 }, 8861 watch: { 8862 disabled(val) { 8863 val && this.callDeactivate(); 8864 }, 8865 isActive(val) { 8866 if (this.disabled) return; 8867 val ? this.callActivate() : this.callDeactivate(); 8868 }, 8869 positionX: 'updateDimensions', 8870 positionY: 'updateDimensions' 8871 }, 8872 beforeMount() { 8873 this.hasWindow = typeof window !== 'undefined'; 8874 if (this.hasWindow) { 8875 window.addEventListener('resize', this.updateDimensions, false); 8876 } 8877 }, 8878 beforeDestroy() { 8879 if (this.hasWindow) { 8880 window.removeEventListener('resize', this.updateDimensions, false); 8881 } 8882 }, 8883 methods: { 8884 absolutePosition() { 8885 return { 8886 offsetTop: this.positionY || this.absoluteY, 8887 offsetLeft: this.positionX || this.absoluteX, 8888 scrollHeight: 0, 8889 top: this.positionY || this.absoluteY, 8890 bottom: this.positionY || this.absoluteY, 8891 left: this.positionX || this.absoluteX, 8892 right: this.positionX || this.absoluteX, 8893 height: 0, 8894 width: 0 8895 }; 8896 }, 8897 activate() {}, 8898 calcLeft(menuWidth) { 8899 return (0,_util_helpers__WEBPACK_IMPORTED_MODULE_7__/* .convertToUnit */ .kb)(this.attach !== false ? this.computedLeft : this.calcXOverflow(this.computedLeft, menuWidth)); 8900 }, 8901 calcTop() { 8902 return (0,_util_helpers__WEBPACK_IMPORTED_MODULE_7__/* .convertToUnit */ .kb)(this.attach !== false ? this.computedTop : this.calcYOverflow(this.computedTop)); 8903 }, 8904 calcXOverflow(left, menuWidth) { 8905 const xOverflow = left + menuWidth - this.pageWidth + 12; 8906 if ((!this.left || this.right) && xOverflow > 0) { 8907 left = Math.max(left - xOverflow, 0); 8908 } else { 8909 left = Math.max(left, 12); 8910 } 8911 return left + this.getOffsetLeft(); 8912 }, 8913 calcYOverflow(top) { 8914 const documentHeight = this.getInnerHeight();
8915 const toTop = this.absoluteYOffset + documentHeight; 8916 const activator = this.dimensions.activator; 8917 const contentHeight = this.dimensions.content.height; 8918 const totalHeight = top + contentHeight; 8919 const isOverflowing = toTop < totalHeight; // If overflowing bottom and offset 8920 // TODO: set 'bottom' position instead of 'top' 8921 8922 if (isOverflowing && this.offsetOverflow && 8923 // If we don't have enough room to offset 8924 // the overflow, don't offset 8925 activator.top > contentHeight) { 8926 top = this.pageYOffset + (activator.top - contentHeight); // If overflowing bottom 8927 } else if (isOverflowing && !this.allowOverflow) { 8928 top = toTop - contentHeight - 12; // If overflowing top 8929 } else if (top < this.absoluteYOffset && !this.allowOverflow) { 8930 top = this.absoluteYOffset + 12; 8931 } 8932 return top < 12 ? 12 : top; 8933 }, 8934 callActivate() { 8935 if (!this.hasWindow) return; 8936 this.activate(); 8937 }, 8938 callDeactivate() { 8939 this.isContentActive = false; 8940 this.deactivate(); 8941 }, 8942 checkForPageYOffset() { 8943 if (this.hasWindow) { 8944 this.pageYOffset = this.activatorFixed ? 0 : this.getOffsetTop(); 8945 } 8946 }, 8947 checkActivatorFixed() { 8948 if (this.attach !== false) { 8949 this.activatorFixed = false; 8950 return; 8951 } 8952 let el = this.getActivator(); 8953 while (el) { 8954 if (window.getComputedStyle(el).position === 'fixed') { 8955 this.activatorFixed = true; 8956 return; 8957 } 8958 el = el.offsetParent; 8959 } 8960 this.activatorFixed = false; 8961 }, 8962 deactivate() {}, 8963 genActivatorListeners() { 8964 const listeners = _activatable__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z.options.methods.genActivatorListeners.call(this); 8965 const onClick = listeners.click; 8966 if (onClick) { 8967 listeners.click = e => { 8968 if (this.openOnClick) { 8969 onClick && onClick(e); 8970 } 8971 this.absoluteX = e.clientX; 8972 this.absoluteY = e.clientY; 8973 }; 8974 } 8975 return listeners; 8976 }, 8977 getInnerHeight() { 8978 if (!this.hasWindow) return 0; 8979 return window.innerHeight || document.documentElement.clientHeight; 8980 }, 8981 getOffsetLeft() { 8982 if (!this.hasWindow) return 0; 8983 return window.pageXOffset || document.documentElement.scrollLeft; 8984 }, 8985 getOffsetTop() { 8986 if (!this.hasWindow) return 0; 8987 return window.pageYOffset || document.documentElement.scrollTop; 8988 }, 8989 getRoundedBoundedClientRect(el) { 8990 const rect = el.getBoundingClientRect(); 8991 return { 8992 top: Math.round(rect.top), 8993 left: Math.round(rect.left), 8994 bottom: Math.round(rect.bottom), 8995 right: Math.round(rect.right),
8996 width: Math.round(rect.width), 8997 height: Math.round(rect.height) 8998 }; 8999 }, 9000 measure(el) { 9001 if (!el || !this.hasWindow) return null; 9002 const rect = this.getRoundedBoundedClientRect(el); // Account for activator margin 9003 9004 if (this.attach !== false) { 9005 const style = window.getComputedStyle(el); 9006 rect.left = parseInt(style.marginLeft); 9007 rect.top = parseInt(style.marginTop); 9008 } 9009 return rect; 9010 }, 9011 sneakPeek(cb) { 9012 requestAnimationFrame(() => { 9013 const el = this.$refs.content; 9014 if (!el || el.style.display !== 'none') { 9015 cb(); 9016 return; 9017 } 9018 el.style.display = 'inline-block'; 9019 cb(); 9020 el.style.display = 'none'; 9021 }); 9022 }, 9023 startTransition() { 9024 return new Promise(resolve => requestAnimationFrame(() => { 9025 this.isContentActive = this.hasJustFocused = this.isActive; 9026 resolve(); 9027 })); 9028 }, 9029 updateDimensions() { 9030 this.hasWindow = typeof window !== 'undefined'; 9031 this.checkActivatorFixed(); 9032 this.checkForPageYOffset(); 9033 this.pageWidth = document.documentElement.clientWidth; 9034 const dimensions = { 9035 activator: _objectSpread({}, this.dimensions.activator), 9036 content: _objectSpread({}, this.dimensions.content) 9037 }; // Activator should already be shown 9038 9039 if (!this.hasActivator || this.absolute) { 9040 dimensions.activator = this.absolutePosition(); 9041 } else { 9042 const activator = this.getActivator(); 9043 if (!activator) return; 9044 dimensions.activator = this.measure(activator); 9045 dimensions.activator.offsetLeft = activator.offsetLeft; 9046 if (this.attach !== false) { 9047 // account for css padding causing things to not line up 9048 // this is mostly for v-autocomplete, hopefully it won't break anything 9049 dimensions.activator.offsetTop = activator.offsetTop; 9050 } else { 9051 dimensions.activator.offsetTop = 0; 9052 } 9053 } // Display and hide to get dimensions 9054 9055 this.sneakPeek(() => { 9056 if (this.$refs.content) { 9057 if (this.$refs.content.offsetParent) { 9058 const offsetRect = this.getRoundedBoundedClientRect(this.$refs.content.offsetParent); 9059 this.relativeYOffset = window.pageYOffset + offsetRect.top; 9060 dimensions.activator.top -= this.relativeYOffset; 9061 dimensions.activator.left -= window.pageXOffset + offsetRect.left; 9062 } 9063 dimensions.content = this.measure(this.$refs.content); 9064 } 9065 this.dimensions = dimensions; 9066 }); 9067 } 9068 } 9069})); 9070 9071/***/ }), 9072 9073/***/ 4287: 9074/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9075 9076"use strict"; 9077/* harmony export */ __webpack_require__.d(__webpack_exports__, { 9078/* harmony export */ d: function() { return /* binding */ factory; } 9079/* harmony export */ }); 9080/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9081/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6539); 9082 9083 9084const availableProps = { 9085 absolute: Boolean, 9086 bottom: Boolean, 9087 fixed: Boolean, 9088 left: Boolean, 9089 right: Boolean, 9090 top: Boolean 9091}; 9092function factory() { 9093 let selected = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 9094 return vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 9095 name: 'positionable', 9096 props: selected.length ? (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .filterObjectOnKeys */ .ji)(availableProps, selected) : availableProps 9097 }); 9098} 9099/* harmony default export */ __webpack_exports__.Z = (factory()); // Add a `*` before the second `/` 9100 9101/* Tests / 9102let single = factory(['top']).extend({ 9103 created () { 9104 this.top 9105 this.bottom 9106 this.absolute 9107 } 9108}) 9109 9110let some = factory(['top', 'bottom']).extend({ 9111 created () { 9112 this.top 9113 this.bottom 9114 this.absolute 9115 } 9116}) 9117 9118let all = factory().extend({ 9119 created () { 9120 this.top 9121 this.bottom 9122 this.absolute 9123 this.foobar 9124 } 9125}) 9126/**/ 9127 9128/***/ }), 9129 9130/***/ 8747: 9131/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9132 9133"use strict"; 9134/* unused harmony export factory */ 9135/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9136 9137function factory() { 9138 let prop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'value'; 9139 let event = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'change'; 9140 return vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 9141 name: 'proxyable', 9142 model: { 9143 prop, 9144 event 9145 }, 9146 props: { 9147 [prop]: { 9148 required: false 9149 } 9150 }, 9151 data() { 9152 return { 9153 internalLazyValue: this[prop] 9154 }; 9155 }, 9156 computed: { 9157 internalValue: { 9158 get() { 9159 return this.internalLazyValue; 9160 }, 9161 set(val) { 9162 if (val === this.internalLazyValue) return; 9163 this.internalLazyValue = val; 9164 this.$emit(event, val); 9165 } 9166 } 9167 }, 9168 watch: { 9169 [prop](val) { 9170 this.internalLazyValue = val; 9171 } 9172 } 9173 }); 9174} 9175/* eslint-disable-next-line @typescript-eslint/no-redeclare */ 9176 9177const Proxyable = factory(); 9178/* harmony default export */ __webpack_exports__.Z = (Proxyable); 9179 9180/***/ }), 9181 9182/***/ 474: 9183/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9184 9185"use strict"; 9186/* harmony export */ __webpack_require__.d(__webpack_exports__, { 9187/* harmony export */ J: function() { return /* binding */ provide; }, 9188/* harmony export */ f: function() { return /* binding */ inject; } 9189/* harmony export */ }); 9190/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(538); 9191/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9206); 9192 9193 9194function generateWarning(child, parent) { 9195 return () => (0,_util_console__WEBPACK_IMPORTED_MODULE_0__/* .consoleWarn */ .Kd)(`The ${child} component must be used inside a ${parent}`); 9196} 9197function inject(namespace, child, parent) { 9198 const defaultImpl = child && parent ? { 9199 register: generateWarning(child, parent), 9200 unregister: generateWarning(child, parent) 9201 } : null; 9202 return vue__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP.extend({ 9203 name: 'registrable-inject', 9204 inject: {
9205 [namespace]: { 9206 default: defaultImpl 9207 } 9208 } 9209 }); 9210} 9211function provide(namespace) { 9212 let self = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 9213 return vue__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP.extend({ 9214 name: 'registrable-provide', 9215 provide() { 9216 return { 9217 [namespace]: self ? this : { 9218 register: this.register, 9219 unregister: this.unregister 9220 } 9221 }; 9222 } 9223 }); 9224} 9225 9226/***/ }), 9227 9228/***/ 6949: 9229/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9230 9231"use strict"; 9232/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9233 9234/* @vue/component */ 9235 9236/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 9237 name: 'returnable', 9238 props: { 9239 returnValue: null 9240 }, 9241 data: () => ({ 9242 isActive: false, 9243 originalValue: null 9244 }), 9245 watch: { 9246 isActive(val) { 9247 if (val) { 9248 this.originalValue = this.returnValue; 9249 } else { 9250 this.$emit('update:return-value', this.originalValue); 9251 } 9252 } 9253 }, 9254 methods: { 9255 save(value) { 9256 this.originalValue = value; 9257 setTimeout(() => { 9258 this.isActive = false; 9259 }); 9260 } 9261 } 9262})); 9263 9264/***/ }), 9265 9266/***/ 4941: 9267/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9268 9269"use strict"; 9270/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1876); 9271/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_0__); 9272/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(538); 9273 9274 9275/* @vue/component */ 9276 9277/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP.extend({ 9278 name: 'roundable', 9279 props: { 9280 rounded: [Boolean, String], 9281 tile: Boolean 9282 }, 9283 computed: {
9284 roundedClasses() { 9285 const composite = []; 9286 const rounded = typeof this.rounded === 'string' ? String(this.rounded) : this.rounded === true; 9287 if (this.tile) { 9288 composite.push('rounded-0'); 9289 } else if (typeof rounded === 'string') { 9290 const values = rounded.split(' '); 9291 for (const value of values) { 9292 composite.push(`rounded-${value}`); 9293 } 9294 } else if (rounded) { 9295 composite.push('rounded'); 9296 } 9297 return composite.length > 0 ? { 9298 [composite.join(' ')]: true 9299 } : {}; 9300 } 9301 } 9302})); 9303 9304/***/ }), 9305 9306/***/ 4520: 9307/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9308 9309"use strict"; 9310/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 9311/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 9312/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9357); 9313/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1__); 9314/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1180); 9315/* harmony import */ var core_js_modules_es6_string_link__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4531); 9316/* harmony import */ var core_js_modules_es6_string_link__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_string_link__WEBPACK_IMPORTED_MODULE_2__); 9317/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(538); 9318/* harmony import */ var _directives_ripple__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4261); 9319/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6539); 9320 9321 9322 9323 9324function 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; } 9325function _objectSpread(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) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(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; } 9326 // Directives 9327 9328 // Utilities 9329 9330 9331/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .ZP.extend({ 9332 name: 'routable', 9333 directives: { 9334 Ripple: _directives_ripple__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z 9335 }, 9336 props: { 9337 activeClass: String, 9338 append: Boolean, 9339 disabled: Boolean, 9340 exact: { 9341 type: Boolean, 9342 default: undefined 9343 }, 9344 exactPath: Boolean, 9345 exactActiveClass: String, 9346 link: Boolean, 9347 href: [String, Object], 9348 to: [String, Object], 9349 nuxt: Boolean, 9350 replace: Boolean, 9351 ripple: { 9352 type: [Boolean, Object], 9353 default: null 9354 }, 9355 tag: String, 9356 target: String 9357 }, 9358 data: () => ({ 9359 isActive: false, 9360 proxyClass: '' 9361 }), 9362 computed: { 9363 classes() { 9364 const classes = {}; 9365 if (this.to) return classes; 9366 if (this.activeClass) classes[this.activeClass] = this.isActive; 9367 if (this.proxyClass) classes[this.proxyClass] = this.isActive; 9368 return classes; 9369 }, 9370 computedRipple() { 9371 var _a; 9372 return (_a = this.ripple) !== null && _a !== void 0 ? _a : !this.disabled && this.isClickable; 9373 }, 9374 isClickable() { 9375 if (this.disabled) return false;
9376 return Boolean(this.isLink || this.$listeners.click || this.$listeners['!click'] || this.$attrs.tabindex); 9377 }, 9378 isLink() { 9379 return this.to || this.href || this.link; 9380 }, 9381 styles: () => ({}) 9382 }, 9383 watch: { 9384 $route: 'onRouteChange' 9385 }, 9386 mounted() { 9387 this.onRouteChange(); 9388 }, 9389 methods: { 9390 generateRouteLink() { 9391 let exact = this.exact; 9392 let tag; 9393 const data = { 9394 attrs: { 9395 tabindex: 'tabindex' in this.$attrs ? this.$attrs.tabindex : undefined 9396 }, 9397 class: this.classes, 9398 style: this.styles, 9399 props: {}, 9400 directives: [{ 9401 name: 'ripple', 9402 value: this.computedRipple 9403 }], 9404 [this.to ? 'nativeOn' : 'on']: _objectSpread(_objectSpread({}, this.$listeners), 'click' in this ? { 9405 click: this.click 9406 } : undefined), 9407 ref: 'link' 9408 }; 9409 if (typeof this.exact === 'undefined') { 9410 exact = this.to === '/' || this.to === Object(this.to) && this.to.path === '/'; 9411 } 9412 if (this.to) { 9413 // Add a special activeClass hook 9414 // for component level styles 9415 let activeClass = this.activeClass; 9416 let exactActiveClass = this.exactActiveClass || activeClass; 9417 if (this.proxyClass) { 9418 activeClass = `${activeClass} ${this.proxyClass}`.trim(); 9419 exactActiveClass = `${exactActiveClass} ${this.proxyClass}`.trim(); 9420 } 9421 tag = this.nuxt ? 'nuxt-link' : 'router-link'; 9422 Object.assign(data.props, { 9423 to: this.to, 9424 exact, 9425 exactPath: this.exactPath, 9426 activeClass, 9427 exactActiveClass, 9428 append: this.append, 9429 replace: this.replace 9430 }); 9431 } else { 9432 tag = this.href && 'a' || this.tag || 'div'; 9433 if (tag === 'a' && this.href) data.attrs.href = this.href; 9434 } 9435 if (this.target) data.attrs.target = this.target; 9436 return { 9437 tag, 9438 data 9439 }; 9440 }, 9441 onRouteChange() { 9442 if (!this.to || !this.$refs.link || !this.$route) return; 9443 const activeClass = `${this.activeClass || ''} ${this.proxyClass || ''}`.trim(); 9444 const exactActiveClass = `${this.exactActiveClass || ''} ${this.proxyClass || ''}`.trim() || activeClass; 9445 const path = '_vnode.data.class.' + (this.exact ? exactActiveClass : activeClass); 9446 this.$nextTick(() => { 9447 /* istanbul ignore else */ 9448 if (!(0,_util_helpers__WEBPACK_IMPORTED_MODULE_6__/* .getObjectValueByPath */ .vO)(this.$refs.link, path) === this.isActive) { 9449 this.toggle(); 9450 } 9451 }); 9452 }, 9453 toggle() { 9454 this.isActive = !this.isActive; 9455 } 9456 } 9457})); 9458 9459/***/ }), 9460 9461/***/ 2144: 9462/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9463 9464"use strict"; 9465/* harmony import */ var core_js_modules_es6_string_small__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3605); 9466/* harmony import */ var core_js_modules_es6_string_small__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_string_small__WEBPACK_IMPORTED_MODULE_0__); 9467/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(538); 9468 9469 9470/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .ZP.extend({ 9471 name: 'sizeable', 9472 props: { 9473 large: Boolean, 9474 small: Boolean, 9475 xLarge: Boolean, 9476 xSmall: Boolean 9477 }, 9478 computed: { 9479 medium() { 9480 return Boolean(!this.xSmall && !this.small && !this.large && !this.xLarge); 9481 }, 9482 sizeableClasses() { 9483 return { 9484 'v-size--x-small': this.xSmall, 9485 'v-size--small': this.small, 9486 'v-size--default': this.medium, 9487 'v-size--large': this.large, 9488 'v-size--x-large': this.xLarge 9489 }; 9490 } 9491 } 9492})); 9493 9494/***/ }), 9495 9496/***/ 4425: 9497/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9498 9499"use strict"; 9500/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9501 9502/** 9503 * SSRBootable 9504 * 9505 * @mixin 9506 * 9507 * Used in layout components (drawer, toolbar, content) 9508 * to avoid an entry animation when using SSR 9509 */ 9510
9511/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 9512 name: 'ssr-bootable', 9513 data: () => ({ 9514 isBooted: false 9515 }), 9516 mounted() { 9517 // Use setAttribute instead of dataset 9518 // because dataset does not work well 9519 // with unit tests 9520 window.requestAnimationFrame(() => { 9521 this.$el.setAttribute('data-booted', 'true'); 9522 this.isBooted = true; 9523 }); 9524 } 9525})); 9526 9527/***/ }), 9528 9529/***/ 6250: 9530/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9531 9532"use strict"; 9533/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9534/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6539); 9535 9536 9537/* @vue/component */ 9538 9539/* harmony default export */ __webpack_exports__.Z = (vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend().extend({ 9540 name: 'stackable', 9541 data() { 9542 return { 9543 stackElement: null, 9544 stackExclude: null, 9545 stackMinZIndex: 0, 9546 isActive: false 9547 }; 9548 }, 9549 computed: { 9550 activeZIndex() { 9551 if (typeof window === 'undefined') return 0; 9552 const content = this.stackElement || this.$refs.content; // Return current zindex if not active 9553 9554 const index = !this.isActive ? (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .getZIndex */ .KK)(content) : this.getMaxZIndex(this.stackExclude || [content]) + 2; 9555 if (index == null) return index; // Return max current z-index (excluding self) + 2 9556 // (2 to leave room for an overlay below, if needed) 9557 9558 return parseInt(index); 9559 } 9560 }, 9561 methods: { 9562 getMaxZIndex() { 9563 let exclude = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; 9564 const base = this.$el; // Start with lowest allowed z-index or z-index of 9565 // base component's element, whichever is greater 9566 9567 const zis = [this.stackMinZIndex, (0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .getZIndex */ .KK)(base)]; // Convert the NodeList to an array to 9568 // prevent an Edge bug with Symbol.iterator 9569 // https://github.com/vuetifyjs/vuetify/issues/2146 9570 9571 const activeElements = [...document.getElementsByClassName('v-menu__content--active'), ...document.getElementsByClassName('v-dialog__content--active')]; // Get z-index for all active dialogs 9572 9573 for (let index = 0; index < activeElements.length; index++) { 9574 if (!exclude.includes(activeElements[index])) { 9575 zis.push((0,_util_helpers__WEBPACK_IMPORTED_MODULE_1__/* .getZIndex */ .KK)(activeElements[index])); 9576 } 9577 } 9578 return Math.max(...zis); 9579 } 9580 } 9581})); 9582 9583/***/ }), 9584 9585/***/ 7416: 9586/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9587 9588"use strict"; 9589/* harmony export */ __webpack_require__.d(__webpack_exports__, { 9590/* harmony export */ X: function() { return /* binding */ functionalThemeClasses; } 9591/* harmony export */ }); 9592/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 9593/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 9594/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1180); 9595/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(538); 9596 9597 9598function 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; } 9599function _objectSpread(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) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEac
9599h(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } 9600 9601/* @vue/component */ 9602 9603const Themeable = vue__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .ZP.extend().extend({ 9604 name: 'themeable', 9605 provide() { 9606 return { 9607 theme: this.themeableProvide 9608 }; 9609 }, 9610 inject: { 9611 theme: { 9612 default: { 9613 isDark: false 9614 } 9615 } 9616 }, 9617 props: { 9618 dark: { 9619 type: Boolean, 9620 default: null 9621 }, 9622 light: { 9623 type: Boolean, 9624 default: null 9625 } 9626 }, 9627 data() { 9628 return { 9629 themeableProvide: { 9630 isDark: false 9631 } 9632 }; 9633 }, 9634 computed: { 9635 appIsDark() { 9636 return this.$vuetify.theme.dark || false; 9637 }, 9638 isDark() { 9639 if (this.dark === true) { 9640 // explicitly dark 9641 return true; 9642 } else if (this.light === true) { 9643 // explicitly light 9644 return false; 9645 } else { 9646 // inherit from parent, or default false if there is none 9647 return this.theme.isDark; 9648 } 9649 }, 9650 themeClasses() { 9651 return { 9652 'theme--dark': this.isDark, 9653 'theme--light': !this.isDark 9654 }; 9655 }, 9656 /** Used by menus and dialogs, inherits from v-app instead of the parent */ 9657 rootIsDark() { 9658 if (this.dark === true) { 9659 // explicitly dark 9660 return true; 9661 } else if (this.light === true) { 9662 // explicitly light 9663 return false; 9664 } else { 9665 // inherit from v-app 9666 return this.appIsDark; 9667 } 9668 }, 9669 rootThemeClasses() { 9670 return { 9671 'theme--dark': this.rootIsDark, 9672 'theme--light': !this.rootIsDark 9673 }; 9674 } 9675 }, 9676 watch: { 9677 isDark: { 9678 handler(newVal, oldVal) { 9679 if (newVal !== oldVal) { 9680 this.themeableProvide.isDark = this.isDark; 9681 } 9682 }, 9683 immediate: true 9684 } 9685 } 9686}); 9687/* harmony default export */ __webpack_exports__.Z = (Themeable); 9688function functionalThemeClasses(context) { 9689 const vm = _objectSpread(_objectSpread({}, context.props), context.injections); 9690 const isDark = Themeable.options.computed.isDark.call(vm); 9691 return Themeable.options.computed.themeClasses.call({ 9692 isDark 9693 }); 9694} 9695 9696/***/ }), 9697 9698/***/ 1796: 9699/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9700 9701"use strict"; 9702/* harmony export */ __webpack_require__.d(__webpack_exports__, { 9703/* harmony export */ d: function() { return /* binding */ factory; } 9704/* harmony export */ }); 9705/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 9706 9707function factory() { 9708 let prop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'value'; 9709 let event = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'input'; 9710 return vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 9711 name: 'toggleable', 9712 model: { 9713 prop, 9714 event 9715 }, 9716 props: { 9717 [prop]: { 9718 required: false 9719 } 9720 }, 9721 data() { 9722 return { 9723 isActive: !!this[prop] 9724 }; 9725 }, 9726 watch: { 9727 [prop](val) { 9728 this.isActive = !!val; 9729 }, 9730 isActive(val) { 9731 !!val !== this[prop] && this.$emit(event, val); 9732 } 9733 } 9734 }); 9735} 9736/* eslint-disable-next-line @typescript-eslint/no-redeclare */ 9737 9738const Toggleable = factory(); 9739/* harmony default export */ __webpack_exports__.Z = (Toggleable); 9740 9741/***/ }), 9742 9743/***/ 7123: 9744/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9745 9746"use strict"; 9747/* harmony import */ var _colorable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8390); 9748/* harmony import */ var _themeable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7416); 9749/* harmony import */ var _registrable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(474); 9750/* harmony import */ var _util_helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 9751/* harmony import */ var _util_console__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9206); 9752/* harmony import */ var _util_mixins__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9547); 9753// Mixins 9754 9755 9756 // Utilities 9757 9758 9759 9760 9761const baseMixins = (0,_util_mixins__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(_colorable__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z, (0,_registrable__WEBPACK_IMPORTED_MODULE_2__/* .inject */ .f)('form'), _themeable__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z); 9762/* @vue/component */ 9763 9764/* harmony default export */ __webpack_exports__.Z = (baseMixins.extend({ 9765 name: 'validatable', 9766 props: { 9767 disabled: { 9768 type: Boolean, 9769 default: null 9770 }, 9771 error: Boolean, 9772 errorCount: { 9773 type: [Number, String], 9774 default: 1 9775 }, 9776 errorMessages: { 9777 type: [String, Array], 9778 default: () => [] 9779 }, 9780 messages: { 9781 type: [String, Array], 9782 default: () => [] 9783 }, 9784 readonly: { 9785 type: Boolean, 9786 default: null 9787 }, 9788 rules: { 9789 type: Array, 9790 default: () => [] 9791 }, 9792 success: Boolean, 9793 successMessages: { 9794 type: [String, Array], 9795 default: () => [] 9796 }, 9797 validateOnBlur: Boolean, 9798 value: { 9799 required: false 9800 } 9801 }, 9802 data() { 9803 return { 9804 errorBucket: [], 9805 hasColor: false, 9806 hasFocused: false,
9807 hasInput: false, 9808 isFocused: false, 9809 isResetting: false, 9810 lazyValue: this.value, 9811 valid: false 9812 }; 9813 }, 9814 computed: { 9815 computedColor() { 9816 if (this.isDisabled) return undefined; 9817 if (this.color) return this.color; // It's assumed that if the input is on a 9818 // dark background, the user will want to 9819 // have a white color. If the entire app 9820 // is setup to be dark, then they will 9821 // like want to use their primary color 9822 9823 if (this.isDark && !this.appIsDark) return 'white';else return 'primary'; 9824 }, 9825 hasError() { 9826 return this.internalErrorMessages.length > 0 || this.errorBucket.length > 0 || this.error; 9827 }, 9828 // TODO: Add logic that allows the user to enable based 9829 // upon a good validation 9830 hasSuccess() { 9831 return this.internalSuccessMessages.length > 0 || this.success; 9832 }, 9833 externalError() { 9834 return this.internalErrorMessages.length > 0 || this.error; 9835 }, 9836 hasMessages() { 9837 return this.validationTarget.length > 0; 9838 }, 9839 hasState() { 9840 if (this.isDisabled) return false; 9841 return this.hasSuccess || this.shouldValidate && this.hasError; 9842 }, 9843 internalErrorMessages() { 9844 return this.genInternalMessages(this.errorMessages); 9845 }, 9846 internalMessages() { 9847 return this.genInternalMessages(this.messages); 9848 }, 9849 internalSuccessMessages() { 9850 return this.genInternalMessages(this.successMessages); 9851 }, 9852 internalValue: { 9853 get() { 9854 return this.lazyValue; 9855 }, 9856 set(val) { 9857 this.lazyValue = val; 9858 this.$emit('input', val); 9859 } 9860 }, 9861 isDisabled() { 9862 var _a; 9863 return (_a = this.disabled) !== null && _a !== void 0 ? _a : !!this.form && this.form.disabled; 9864 }, 9865 isInteractive() { 9866 return !this.isDisabled && !this.isReadonly; 9867 }, 9868 isReadonly() { 9869 var _a; 9870 return (_a = this.readonly) !== null && _a !== void 0 ? _a : !!this.form && this.form.readonly; 9871 }, 9872 shouldValidate() { 9873 if (this.externalError) return true; 9874 if (this.isResetting) return false; 9875 return this.validateOnBlur ? this.hasFocused && !this.isFocused : this.hasInput || this.hasFocused; 9876 }, 9877 validations() { 9878 return this.validationTarget.slice(0, Number(this.errorCount)); 9879 }, 9880 validationState() { 9881 if (this.isDisabled) return undefined; 9882 if (this.hasError && this.shouldValidate) return 'error'; 9883 if (this.hasSuccess) return 'success'; 9884 if (this.hasColor) return this.computedColor; 9885 return undefined; 9886 }, 9887 validationTarget() { 9888 if (this.internalErrorMessages.length > 0) { 9889 return this.internalErrorMessages; 9890 } else if (this.successMessages && this.successMessages.length > 0) { 9891 return this.internalSuccessMessages; 9892 } else if (this.messages && this.messages.length > 0) { 9893 return this.internalMessages; 9894 } else if (this.shouldValidate) { 9895 return this.errorBucket; 9896 } else return []; 9897 } 9898 }, 9899 watch: { 9900 rules: { 9901 handler(newVal, oldVal) { 9902 if ((0,_util_helpers__WEBPACK_IMPORTED_MODULE_4__/* .deepEqual */ .vZ)(newVal, oldVal)) return; 9903 this.validate(); 9904 }, 9905 deep: true 9906 }, 9907 internalValue() { 9908 // If it's the first time we're setting input, 9909 // mark it with hasInput 9910 this.hasInput = true; 9911 this.validateOnBlur || this.$nextTick(this.validate); 9912 }, 9913 isFocused(val) { 9914 // Should not check validation 9915 // if disabled 9916 if (!val && !this.isDisabled) { 9917 this.hasFocused = true; 9918 this.validateOnBlur && this.$nextTick(this.validate); 9919 } 9920 }, 9921 isResetting() { 9922 setTimeout(() => { 9923 this.hasInput = false; 9924 this.hasFocused = false; 9925 this.isResetting = false; 9926 this.validate(); 9927 }, 0); 9928 }, 9929 hasError(val) { 9930 if (this.shouldValidate) { 9931 this.$emit('update:error', val); 9932 } 9933 }, 9934 value(val) { 9935 this.lazyValue = val; 9936 } 9937 }, 9938 beforeMount() { 9939 this.validate(); 9940 }, 9941 created() { 9942 this.form && this.form.register(this); 9943 }, 9944 beforeDestroy() { 9945 this.form && this.form.unregister(this); 9946 }, 9947 methods: { 9948 genInternalMessages(messages) { 9949 if (!messages) return [];else if (Array.isArray(messages)) return messages;else return [messages]; 9950 }, 9951 /** @public */ 9952 reset() { 9953 this.isResetting = true; 9954 this.internalValue = Array.isArray(this.internalValue) ? [] : null; 9955 }, 9956 /** @public */ 9957 resetValidation() { 9958 this.isResetting = true; 9959 }, 9960 /** @public */ 9961 validate() { 9962 let force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
9963 let value = arguments.length > 1 ? arguments[1] : undefined; 9964 const errorBucket = []; 9965 value = value || this.internalValue; 9966 if (force) this.hasInput = this.hasFocused = true; 9967 for (let index = 0; index < this.rules.length; index++) { 9968 const rule = this.rules[index]; 9969 const valid = typeof rule === 'function' ? rule(value) : rule; 9970 if (valid === false || typeof valid === 'string') { 9971 errorBucket.push(valid || ''); 9972 } else if (typeof valid !== 'boolean') { 9973 (0,_util_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleError */ .N6)(`Rules should return a string or boolean, received '${typeof valid}' instead`, this); 9974 } 9975 } 9976 this.errorBucket = errorBucket; 9977 this.valid = errorBucket.length === 0; 9978 return this.valid; 9979 } 9980 } 9981})); 9982 9983/***/ }), 9984 9985/***/ 60: 9986/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 9987 9988"use strict"; 9989 9990// EXPORTS 9991__webpack_require__.d(__webpack_exports__, { 9992 A: function() { return /* binding */ Goto; }, 9993 Z: function() { return /* binding */ goTo; } 9994}); 9995 9996// NAMESPACE OBJECT: ./node_modules/vuetify/lib/services/goto/easing-patterns.js 9997var easing_patterns_namespaceObject = {}; 9998__webpack_require__.r(easing_patterns_namespaceObject); 9999__webpack_require__.d(easing_patterns_namespaceObject, { 10000 easeInCubic: function() { return easeInCubic; }, 10001 easeInOutCubic: function() { return easeInOutCubic; }, 10002 easeInOutQuad: function() { return easeInOutQuad; }, 10003 easeInOutQuart: function() { return easeInOutQuart; }, 10004 easeInOutQuint: function() { return easeInOutQuint; }, 10005 easeInQuad: function() { return easeInQuad; }, 10006 easeInQuart: function() { return easeInQuart; }, 10007 easeInQuint: function() { return easeInQuint; }, 10008 easeOutCubic: function() { return easeOutCubic; }, 10009 easeOutQuad: function() { return easeOutQuad; }, 10010 easeOutQuart: function() { return easeOutQuart; }, 10011 easeOutQuint: function() { return easeOutQuint; }, 10012 linear: function() { return linear; } 10013}); 10014 10015// EXTERNAL MODULE: ./node_modules/core-js/modules/web.dom.iterable.js 10016var web_dom_iterable = __webpack_require__(1181); 10017// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js + 3 modules 10018var defineProperty = __webpack_require__(1180); 10019// EXTERNAL MODULE: ./node_modules/vuetify/lib/services/service/index.js 10020var service = __webpack_require__(3931); 10021;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/goto/easing-patterns.js 10022// linear 10023const linear = t => t; // accelerating from zero velocity 10024 10025const easeInQuad = t => t ** 2; // decelerating to zero velocity 10026 10027const easeOutQuad = t => t * (2 - t); // acceleration until halfway, then deceleration 10028 10029const easeInOutQuad = t => t < 0.5 ? 2 * t ** 2 : -1 + (4 - 2 * t) * t; // accelerating from zero velocity 10030 10031const easeInCubic = t => t ** 3; // decelerating to zero velocity 10032 10033const easeOutCubic = t => --t ** 3 + 1; // acceleration until halfway, then deceleration 10034 10035const easeInOutCubic = t => t < 0.5 ? 4 * t ** 3 : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1; // accelerating from zero velocity 10036 10037const easeInQuart = t => t ** 4; // decelerating to zero velocity 10038 10039const easeOutQuart = t => 1 - --t ** 4; // acceleration until halfway, then deceleration 10040 10041const easeInOutQuart = t => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t; // accelerating from zero velocity 10042 10043const easeInQuint = t => t ** 5; // decelerating to zero velocity 10044 10045const easeOutQuint = t => 1 + --t ** 5; // acceleration until halfway, then deceleration 10046 10047const easeInOutQuint = t => t < 0.5 ? 16 * t ** 5 : 1 + 16 * --t ** 5; 10048;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/goto/util.js 10049// Return target's cumulative offset from the top 10050function getOffset(target) { 10051 if (typeof target === 'number') { 10052 return target; 10053 } 10054 let el = $(target); 10055 if (!el) { 10056 throw typeof target === 'string' ? new Error(`Target element "${target}" not found.`) : new TypeError(`Target must be a Number/Selector/HTMLElement/VueComponent, received ${type(target)} instead.`); 10057 } 10058 let totalOffset = 0; 10059 while (el) { 10060 totalOffset += el.offsetTop; 10061 el = el.offsetParent; 10062 } 10063 return totalOffset; 10064} 10065function getContainer(container) { 10066 const el = $(container); 10067 if (el) return el; 10068 throw typeof container === 'string' ? new Error(`Container element "${container}" not found.`) : new TypeError(`Container must be a Selector/HTMLElement/VueComponent, received ${type(container)} instead.`); 10069} 10070function type(el) { 10071 return el == null ? el : el.constructor.name; 10072} 10073function $(el) { 10074 if (typeof el === 'string') { 10075 return document.querySelector(el); 10076 } else if (el && el._isVue) { 10077 return el.$el; 10078 } else if (el instanceof HTMLElement) { 10079 return el; 10080 } else { 10081 return null; 10082 } 10083} 10084;// CONCATENATED MODULE: ./node_modules/vuetify/lib/services/goto/index.js 10085 10086 10087function 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; } 10088function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
10088 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,defineProperty/* default */.Z)(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; } 10089// Extensions 10090 // Utilities 10091 10092 10093 10094function goTo(_target) { 10095 let _settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10096 const settings = _objectSpread({ 10097 container: document.scrollingElement || document.body || document.documentElement, 10098 duration: 500, 10099 offset: 0, 10100 easing: 'easeInOutCubic', 10101 appOffset: true 10102 }, _settings); 10103 const container = getContainer(settings.container); 10104 /* istanbul ignore else */ 10105 10106 if (settings.appOffset && goTo.framework.application) { 10107 const isDrawer = container.classList.contains('v-navigation-drawer'); 10108 const isClipped = container.classList.contains('v-navigation-drawer--clipped'); 10109 const _goTo$framework$appli = goTo.framework.application, 10110 bar = _goTo$framework$appli.bar, 10111 top = _goTo$framework$appli.top; 10112 settings.offset += bar; 10113 /* istanbul ignore else */ 10114 10115 if (!isDrawer || isClipped) settings.offset += top; 10116 } 10117 const startTime = performance.now(); 10118 let targetLocation; 10119 if (typeof _target === 'number') { 10120 targetLocation = getOffset(_target) - settings.offset; 10121 } else { 10122 targetLocation = getOffset(_target) - getOffset(container) - settings.offset; 10123 } 10124 const startLocation = container.scrollTop; 10125 if (targetLocation === startLocation) return Promise.resolve(targetLocation); 10126 const ease = typeof settings.easing === 'function' ? settings.easing : easing_patterns_namespaceObject[settings.easing]; 10127 /* istanbul ignore else */ 10128 10129 if (!ease) throw new TypeError(`Easing function "${settings.easing}" not found.`); // Cannot be tested properly in jsdom 10130 10131 /* istanbul ignore next */ 10132 10133 return new Promise(resolve => requestAnimationFrame(function step(currentTime) { 10134 const timeElapsed = currentTime - startTime; 10135 const progress = Math.abs(settings.duration ? Math.min(timeElapsed / settings.duration, 1) : 1); 10136 container.scrollTop = Math.floor(startLocation + (targetLocation - startLocation) * ease(progress)); 10137 const clientHeight = container === document.body ? document.documentElement.clientHeight : container.clientHeight; 10138 const reachBottom = clientHeight + container.scrollTop >= container.scrollHeight; 10139 if (progress === 1 || 10140 // Need to go lower but reach bottom 10141 targetLocation > container.scrollTop && reachBottom) { 10142 return resolve(targetLocation); 10143 } 10144 requestAnimationFrame(step); 10145 })); 10146} 10147goTo.framework = {}; 10148goTo.init = () => {}; 10149class Goto extends service/* Service */.t { 10150 constructor() { 10151 super(); 10152 return goTo; 10153 } 10154} 10155Goto.property = 'goTo'; 10156 10157/***/ }), 10158 10159/***/ 3931: 10160/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10161 10162"use strict"; 10163/* harmony export */ __webpack_require__.d(__webpack_exports__, { 10164/* harmony export */ t: function() { return /* binding */ Service; } 10165/* harmony export */ }); 10166class Service { 10167 constructor() { 10168 this.framework = {}; 10169 } 10170 init(root, ssrContext) {} 10171} 10172 10173/***/ }), 10174 10175/***/ 2787: 10176/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10177 10178"use strict"; 10179/* harmony export */ __webpack_require__.d(__webpack_exports__, { 10180/* harmony export */ I4: function() { return /* binding */ intToHex; }, 10181/* harmony export */ NA: function() { return /* binding */ isCssColor; }, 10182/* harmony export */ hq: function() { return /* binding */ colorToHex; }, 10183/* harmony export */ jx: function() { return /* binding */ colorToInt; } 10184/* harmony export */ }); 10185/* unused harmony exports classToHex, HSVAtoRGBA, RGBAtoHSVA, HSVAtoHSLA, HSLAtoHSVA, RGBAtoCSS, RGBtoCSS, RGBAtoHex, HexToRGBA, HexToHSVA, HSVAtoHex, parseHex, parseGradient, RGBtoInt, contrastRatio */ 10186/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 10187/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 10188/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6108); 10189/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_1__); 10190/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9357); 10191/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_2__); 10192/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1876); 10193/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_3__); 10194/* harmony import */ var core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1466); 10195/* harmony import */ var core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_4__); 10196/* harmony import */ var _console__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9206); 10197 10198 10199 10200 10201 10202 10203 10204function 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; } 10205function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
10205 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; } 10206// Utilities 10207 10208 10209 10210function isCssColor(color) { 10211 return !!color && !!color.match(/^(#|var\(--|(rgb|hsl)a?\()/); 10212} 10213function colorToInt(color) { 10214 let rgb; 10215 if (typeof color === 'number') { 10216 rgb = color; 10217 } else if (typeof color === 'string') { 10218 let c = color[0] === '#' ? color.substring(1) : color; 10219 if (c.length === 3) { 10220 c = c.split('').map(char => char + char).join(''); 10221 } 10222 if (c.length !== 6) { 10223 (0,_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleWarn */ .Kd)(`'${color}' is not a valid rgb color`); 10224 } 10225 rgb = parseInt(c, 16); 10226 } else { 10227 throw new TypeError(`Colors can only be numbers or strings, recieved ${color == null ? color : color.constructor.name} instead`); 10228 } 10229 if (rgb < 0) { 10230 (0,_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleWarn */ .Kd)(`Colors cannot be negative: '${color}'`); 10231 rgb = 0; 10232 } else if (rgb > 0xffffff || isNaN(rgb)) { 10233 (0,_console__WEBPACK_IMPORTED_MODULE_5__/* .consoleWarn */ .Kd)(`'${color}' is not a valid rgb color`); 10234 rgb = 0xffffff; 10235 } 10236 return rgb; 10237} 10238function classToHex(color, colors, currentTheme) { 10239 const _color$toString$trim$ = color.toString().trim().replace('-', '').split(' ', 2), 10240 _color$toString$trim$2 = _slicedToArray(_color$toString$trim$, 2), 10241 colorName = _color$toString$trim$2[0], 10242 colorModifier = _color$toString$trim$2[1]; 10243 let hexColor = ''; 10244 if (colorName && colorName in colors) { 10245 if (colorModifier && colorModifier in colors[colorName]) { 10246 hexColor = colors[colorName][colorModifier]; 10247 } else if ('base' in colors[colorName]) { 10248 hexColor = colors[colorName].base; 10249 } 10250 } else if (colorName && colorName in currentTheme) { 10251 hexColor = currentTheme[colorName]; 10252 } 10253 return hexColor; 10254} 10255function intToHex(color) { 10256 let hexColor = color.toString(16); 10257 if (hexColor.length < 6) hexColor = '0'.repeat(6 - hexColor.length) + hexColor; 10258 return '#' + hexColor; 10259} 10260function colorToHex(color) { 10261 return intToHex(colorToInt(color)); 10262} 10263/** 10264 * Converts HSVA to RGBA. Based on formula from https://en.wikipedia.org/wiki/HSL_and_HSV 10265 * 10266 * @param color HSVA color as an array [0-360, 0-1, 0-1, 0-1] 10267 */ 10268 10269function HSVAtoRGBA(hsva) { 10270 const h = hsva.h, 10271 s = hsva.s, 10272 v = hsva.v, 10273 a = hsva.a; 10274 const f = n => { 10275 const k = (n + h / 60) % 6; 10276 return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0); 10277 }; 10278 const rgb = [f(5), f(3), f(1)].map(v => Math.round(v * 255)); 10279 return { 10280 r: rgb[0], 10281 g: rgb[1], 10282 b: rgb[2], 10283 a 10284 }; 10285} 10286/** 10287 * Converts RGBA to HSVA. Based on formula from https://en.wikipedia.org/wiki/HSL_and_HSV 10288 * 10289 * @param color RGBA color as an array [0-255, 0-255, 0-255, 0-1] 10290 */ 10291 10292function RGBAtoHSVA(rgba) { 10293 if (!rgba) return { 10294 h: 0, 10295 s: 1, 10296 v: 1, 10297 a: 1 10298 }; 10299 const r = rgba.r / 255; 10300 const g = rgba.g / 255; 10301 const b = rgba.b / 255; 10302 const max = Math.max(r, g, b); 10303 const min = Math.min(r, g, b); 10304 let h = 0; 10305 if (max !== min) { 10306 if (max === r) { 10307 h = 60 * (0 + (g - b) / (max - min)); 10308 } else if (max === g) { 10309 h = 60 * (2 + (b - r) / (max - min)); 10310 } else if (max === b) { 10311 h = 60 * (4 + (r - g) / (max - min)); 10312 } 10313 } 10314 if (h < 0) h = h + 360; 10315 const s = max === 0 ? 0 : (max - min) / max; 10316 const hsv = [h, s, max]; 10317 return { 10318 h: hsv[0], 10319 s: hsv[1], 10320 v: hsv[2], 10321 a: rgba.a 10322 }; 10323} 10324function HSVAtoHSLA(hsva) { 10325 const h = hsva.h, 10326 s = hsva.s, 10327 v = hsva.v, 10328 a = hsva.a; 10329 const l = v - v * s / 2; 10330 const sprime = l === 1 || l === 0 ? 0 : (v - l) / Math.min(l, 1 - l); 10331 return { 10332 h, 10333 s: sprime, 10334 l, 10335 a 10336 }; 10337} 10338function HSLAtoHSVA(hsl) { 10339 const h = hsl.h, 10340 s = hsl.s, 10341 l = hsl.l, 10342 a = hsl.a; 10343 const v = l + s * Math.min(l, 1 - l); 10344 const sprime = v === 0 ? 0 : 2 - 2 * l / v; 10345 return { 10346 h, 10347 s: sprime, 10348 v, 10349 a 10350 }; 10351} 10352function RGBAtoCSS(rgba) { 10353 return `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${rgba.a}
10353)`; 10354} 10355function RGBtoCSS(rgba) { 10356 return RGBAtoCSS(_objectSpread(_objectSpread({}, rgba), {}, { 10357 a: 1 10358 })); 10359} 10360function RGBAtoHex(rgba) { 10361 const toHex = v => { 10362 const h = Math.round(v).toString(16); 10363 return ('00'.substr(0, 2 - h.length) + h).toUpperCase(); 10364 }; 10365 return `#${[toHex(rgba.r), toHex(rgba.g), toHex(rgba.b), toHex(Math.round(rgba.a * 255))].join('')}`; 10366} 10367function HexToRGBA(hex) { 10368 const rgba = chunk(hex.slice(1), 2).map(c => parseInt(c, 16)); 10369 return { 10370 r: rgba[0], 10371 g: rgba[1], 10372 b: rgba[2], 10373 a: Math.round(rgba[3] / 255 * 100) / 100 10374 }; 10375} 10376function HexToHSVA(hex) { 10377 const rgb = HexToRGBA(hex); 10378 return RGBAtoHSVA(rgb); 10379} 10380function HSVAtoHex(hsva) { 10381 return RGBAtoHex(HSVAtoRGBA(hsva)); 10382} 10383function parseHex(hex) { 10384 if (hex.startsWith('#')) { 10385 hex = hex.slice(1); 10386 } 10387 hex = hex.replace(/([^0-9a-f])/gi, 'F'); 10388 if (hex.length === 3 || hex.length === 4) { 10389 hex = hex.split('').map(x => x + x).join(''); 10390 } 10391 if (hex.length === 6) { 10392 hex = padEnd(hex, 8, 'F'); 10393 } else { 10394 hex = padEnd(padEnd(hex, 6), 8, 'F'); 10395 } 10396 return `#${hex}`.toUpperCase().substr(0, 9); 10397} 10398function parseGradient(gradient, colors, currentTheme) { 10399 return gradient.replace(/([a-z]+(\s[a-z]+-[1-5])?)(?=$|,)/gi, x => { 10400 return classToHex(x, colors, currentTheme) || x; 10401 }).replace(/(rgba\()#[0-9a-f]+(?=,)/gi, x => { 10402 return 'rgba(' + Object.values(HexToRGBA(parseHex(x.replace(/rgba\(/, '')))).slice(0, 3).join(','); 10403 }); 10404} 10405function RGBtoInt(rgba) { 10406 return (rgba.r << 16) + (rgba.g << 8) + rgba.b; 10407} 10408/** 10409 * Returns the contrast ratio (1-21) between two colors. 10410 * 10411 * @param c1 First color 10412 * @param c2 Second color 10413 */ 10414 10415function contrastRatio(c1, c2) { 10416 const _toXYZ = toXYZ(RGBtoInt(c1)), 10417 _toXYZ2 = _slicedToArray(_toXYZ, 2), 10418 y1 = _toXYZ2[1]; 10419 const _toXYZ3 = toXYZ(RGBtoInt(c2)), 10420 _toXYZ4 = _slicedToArray(_toXYZ3, 2), 10421 y2 = _toXYZ4[1]; 10422 return (Math.max(y1, y2) + 0.05) / (Math.min(y1, y2) + 0.05); 10423} 10424 10425/***/ }), 10426 10427/***/ 9206: 10428/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10429 10430"use strict"; 10431/* harmony export */ __webpack_require__.d(__webpack_exports__, { 10432/* harmony export */ Jk: function() { return /* binding */ removed; }, 10433/* harmony export */ Kd: function() { return /* binding */ consoleWarn; }, 10434/* harmony export */ N6: function() { return /* binding */ consoleError; }, 10435/* harmony export */ Rn: function() { return /* binding */ deprecate; }, 10436/* harmony export */ fK: function() { return /* binding */ breaking; } 10437/* harmony export */ }); 10438/* unused harmony export consoleInfo */ 10439/* harmony import */ var core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1466); 10440/* harmony import */ var core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_match__WEBPACK_IMPORTED_MODULE_0__); 10441/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9357); 10442/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_1__); 10443/* harmony import */ var _framework__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3359); 10444 10445 10446/* eslint-disable no-console */ 10447 10448function createMessage(message, vm, parent) { 10449 if (_framework__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z.config.silent) return; 10450 if (parent) { 10451 vm = { 10452 _isVue: true, 10453 $parent: parent, 10454 $options: vm 10455 }; 10456 } 10457 if (vm) { 10458 // Only show each message once per instance 10459 vm.$_alreadyWarned = vm.$_alreadyWarned || []; 10460 if (vm.$_alreadyWarned.includes(message)) return; 10461 vm.$_alreadyWarned.push(message); 10462 } 10463 return `[Vuetify] ${message}` + (vm ? generateComponentTrace(vm) : ''); 10464} 10465function consoleInfo(message, vm, parent) { 10466 const newMessage = createMessage(message, vm, parent); 10467 newMessage != null && console.info(newMessage); 10468} 10469function consoleWarn(message, vm, parent) { 10470 const newMessage = createMessage(message, vm, parent); 10471 newMessage != null && console.warn(newMessage); 10472} 10473function consoleError(message, vm, parent) { 10474 const newMessage = createMessage(message, vm, parent); 10475 newMessage != null && console.error(newMessage); 10476} 10477function deprecate(original, replacement, vm, parent) { 10478 consoleWarn(`[UPGRADE] '${original}' is deprecated, use '${replacement}' instead.`, vm, parent); 10479}
10480function breaking(original, replacement, vm, parent) { 10481 consoleError(`[BREAKING] '${original}' has been removed, use '${replacement}' instead. For more information, see the upgrade guide https://github.com/vuetifyjs/vuetify/releases/tag/v2.0.0#user-content-upgrade-guide`, vm, parent); 10482} 10483function removed(original, vm, parent) { 10484 consoleWarn(`[REMOVED] '${original}' has been removed. You can safely omit it.`, vm, parent); 10485} 10486/** 10487 * Shamelessly stolen from vuejs/vue/blob/dev/src/core/util/debug.js 10488 */ 10489 10490const classifyRE = /(?:^|[-_])(\w)/g; 10491const classify = str => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, ''); 10492function formatComponentName(vm, includeFile) { 10493 if (vm.$root === vm) { 10494 return '<Root>'; 10495 } 10496 const options = typeof vm === 'function' && vm.cid != null ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm || {}; 10497 let name = options.name || options._componentTag; 10498 const file = options.__file; 10499 if (!name && file) { 10500 const match = file.match(/([^/\\]+)\.vue$/); 10501 name = match && match[1]; 10502 } 10503 return (name ? `<${classify(name)}>` : `<Anonymous>`) + (file && includeFile !== false ? ` at ${file}` : ''); 10504} 10505function generateComponentTrace(vm) { 10506 if (vm._isVue && vm.$parent) { 10507 const tree = []; 10508 let currentRecursiveSequence = 0; 10509 while (vm) { 10510 if (tree.length > 0) { 10511 const last = tree[tree.length - 1]; 10512 if (last.constructor === vm.constructor) { 10513 currentRecursiveSequence++; 10514 vm = vm.$parent; 10515 continue; 10516 } else if (currentRecursiveSequence > 0) { 10517 tree[tree.length - 1] = [last, currentRecursiveSequence]; 10518 currentRecursiveSequence = 0; 10519 } 10520 } 10521 tree.push(vm); 10522 vm = vm.$parent; 10523 } 10524 return '\n\nfound in\n\n' + tree.map((vm, i) => `${i === 0 ? '---> ' : ' '.repeat(5 + i * 2)}${Array.isArray(vm) ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)` : formatComponentName(vm)}`).join('\n'); 10525 } else { 10526 return `\n\n(found in ${formatComponentName(vm)})`; 10527 } 10528} 10529 10530/***/ }), 10531 10532/***/ 8616: 10533/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10534 10535"use strict"; 10536/* harmony export */ __webpack_require__.d(__webpack_exports__, { 10537/* harmony export */ e: function() { return /* binding */ attachedRoot; } 10538/* harmony export */ }); 10539/** 10540 * Returns: 10541 * - 'null' if the node is not attached to the DOM 10542 * - the root node (HTMLDocument | ShadowRoot) otherwise 10543 */ 10544function attachedRoot(node) { 10545 /* istanbul ignore next */ 10546 if (typeof node.getRootNode !== 'function') { 10547 // Shadow DOM not supported (IE11), lets find the root of this node 10548 while (node.parentNode) node = node.parentNode; // The root parent is the document if the node is attached to the DOM 10549 10550 if (node !== document) return null; 10551 return document; 10552 } 10553 const root = node.getRootNode(); // The composed root node is the document if the node is attached to the DOM 10554 10555 if (root !== document && root.getRootNode({ 10556 composed: true 10557 }) !== document) return null; 10558 return root; 10559} 10560 10561/***/ }), 10562 10563/***/ 6539: 10564/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 10565 10566"use strict"; 10567/* harmony export */ __webpack_require__.d(__webpack_exports__, { 10568/* harmony export */ Do: function() { return /* binding */ keyCodes; }, 10569/* harmony export */ Ee: function() { return /* binding */ mergeDeep; }, 10570/* harmony export */ GL: function() { return /* binding */ kebabCase; }, 10571/* harmony export */ Ji: function() { return /* binding */ createSimpleFunctional; }, 10572/* harmony export */ KK: function() { return /* binding */ getZIndex; }, 10573/* harmony export */ RB: function() { return /* binding */ remapInternalIcon; }, 10574/* harmony export */ TI: function() { return /* binding */ wrapInArray; }, 10575/* harmony export */ XP: function() { return /* binding */ keys; }, 10576/* harmony export */ _A: function() { return /* binding */ camelize; }, 10577/* harmony export */ iZ: function() { return /* binding */ composedPath; }, 10578/* harmony export */ jC: function() { return /* binding */ upperFirst; },
10579/* harmony export */ ji: function() { return /* binding */ filterObjectOnKeys; }, 10580/* harmony export */ kb: function() { return /* binding */ convertToUnit; }, 10581/* harmony export */ lj: function() { return /* binding */ addPassiveEventListener; }, 10582/* harmony export */ qF: function() { return /* binding */ getPropertyFromItem; }, 10583/* harmony export */ qh: function() { return /* binding */ addOnceEventListener; }, 10584/* harmony export */ qw: function() { return /* binding */ getNestedValue; }, 10585/* harmony export */ sp: function() { return /* binding */ getSlotType; }, 10586/* harmony export */ uZ: function() { return /* binding */ clamp; }, 10587/* harmony export */ vO: function() { return /* binding */ getObjectValueByPath; }, 10588/* harmony export */ vZ: function() { return /* binding */ deepEqual; }, 10589/* harmony export */ z9: function() { return /* binding */ getSlot; } 10590/* harmony export */ }); 10591/* unused harmony exports directiveConfig, passiveSupported, createRange, isObject, arrayDiff, groupItems, sortItems, defaultFilter, searchItems, debounce, throttle, getPrefixedScopedSlots, padEnd, chunk, humanReadableFileSize, camelizeObjectKeys, fillArray */ 10592/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6108); 10593/* harmony import */ var core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_to_string__WEBPACK_IMPORTED_MODULE_0__); 10594/* harmony import */ var core_js_modules_es6_array_sort__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(75); 10595/* harmony import */ var core_js_modules_es6_array_sort__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_array_sort__WEBPACK_IMPORTED_MODULE_1__); 10596/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1876); 10597/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_2__); 10598/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1181); 10599/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_3__); 10600/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9357); 10601/* harmony import */ var core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_replace__WEBPACK_IMPORTED_MODULE_4__); 10602/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(538); 10603 10604 10605 10606 10607 10608 10609 10610function 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; } 10611function _objectSpread(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; } 10612 10613function createSimpleFunctional(c) { 10614 let el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'div'; 10615 let name = arguments.length > 2 ? arguments[2] : undefined; 10616 return vue__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .ZP.extend({ 10617 name: name || c.replace(/__/g, '-'), 10618 functional: true, 10619 props: { 10620 tag: { 10621 type: String, 10622 default: el 10623 } 10624 }, 10625 render(h, _ref) { 10626 let data = _ref.data, 10627 props = _ref.props, 10628 children = _ref.children; 10629 data.staticClass = `${c} ${data.staticClass || ''}`.trim(); 10630 return h(props.tag, data, children); 10631 } 10632 }); 10633} 10634function directiveConfig(binding) { 10635 let defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10636 return _objectSpread(_objectSpread(_objectSpread({}, defaults), binding.modifiers), {}, { 10637 value: binding.arg 10638 }, binding.value || {}); 10639} 10640function addOnceEventListener(el, eventName, cb) { 10641 let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
10642 const once = event => { 10643 cb(event); 10644 el.removeEventListener(eventName, once, options); 10645 }; 10646 el.addEventListener(eventName, once, options); 10647} 10648let passiveSupported = false; 10649try { 10650 if (typeof window !== 'undefined') { 10651 const testListenerOpts = Object.defineProperty({}, 'passive', { 10652 get: () => { 10653 passiveSupported = true; 10654 } 10655 }); 10656 window.addEventListener('testListener', testListenerOpts, testListenerOpts); 10657 window.removeEventListener('testListener', testListenerOpts, testListenerOpts); 10658 } 10659} catch (e) { 10660 console.warn(e); 10661} 10662/* eslint-disable-line no-console */ 10663 10664 10665function addPassiveEventListener(el, event, cb, options) { 10666 el.addEventListener(event, cb, passiveSupported ? options : false); 10667} 10668function getNestedValue(obj, path, fallback) { 10669 const last = path.length - 1; 10670 if (last < 0) return obj === undefined ? fallback : obj; 10671 for (let i = 0; i < last; i++) { 10672 if (obj == null) { 10673 return fallback; 10674 } 10675 obj = obj[path[i]]; 10676 } 10677 if (obj == null) return fallback; 10678 return obj[path[last]] === undefined ? fallback : obj[path[last]]; 10679} 10680function deepEqual(a, b) { 10681 if (a === b) return true; 10682 if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) { 10683 // If the values are Date, compare them as timestamps 10684 return false; 10685 } 10686 if (a !== Object(a) || b !== Object(b)) { 10687 // If the values aren't objects, they were already checked for equality 10688 return false; 10689 } 10690 const props = Object.keys(a); 10691 if (props.length !== Object.keys(b).length) { 10692 // Different number of props, don't bother to check 10693 return false; 10694 } 10695 return props.every(p => deepEqual(a[p], b[p])); 10696} 10697function getObjectValueByPath(obj, path, fallback) { 10698 // credit: http://stackoverflow.com/questions/6491463/accessing-nested-javascript-objects-with-string-key#comment55278413_6491621 10699 if (obj == null || !path || typeof path !== 'string') return fallback; 10700 if (obj[path] !== undefined) return obj[path]; 10701 path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties 10702 10703 path = path.replace(/^\./, ''); // strip a leading dot 10704 10705 return getNestedValue(obj, path.split('.'), fallback); 10706} 10707function getPropertyFromItem(item, property, fallback) { 10708 if (property == null) return item === undefined ? fallback : item; 10709 if (item !== Object(item)) return fallback === undefined ? item : fallback; 10710 if (typeof property === 'string') return getObjectValueByPath(item, property, fallback); 10711 if (Array.isArray(property)) return getNestedValue(item, property, fallback); 10712 if (typeof property !== 'function') return fallback; 10713 const value = property(item, fallback); 10714 return typeof value === 'undefined' ? fallback : value; 10715} 10716function createRange(length) { 10717 return Array.from({ 10718 length 10719 }, (v, k) => k); 10720} 10721function getZIndex(el) { 10722 if (!el || el.nodeType !== Node.ELEMENT_NODE) return 0; 10723 const index = +window.getComputedStyle(el).getPropertyValue('z-index'); 10724 if (!index) return getZIndex(el.parentNode); 10725 return index; 10726} 10727function filterObjectOnKeys(obj, keys) { 10728 const filtered = {}; 10729 for (let i = 0; i < keys.length; i++) { 10730 const key = keys[i]; 10731 if (typeof obj[key] !== 'undefined') { 10732 filtered[key] = obj[key]; 10733 } 10734 } 10735 return filtered; 10736} 10737function convertToUnit(str) { 10738 let unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'px'; 10739 if (str == null || str === '') { 10740 return undefined; 10741 } else if (isNaN(+str)) { 10742 return String(str); 10743 } else { 10744 return `${Number(str)}${unit}`; 10745 } 10746} 10747function kebabCase(str) { 10748 return (str || '').replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(); 10749} 10750function isObject(obj) { 10751 return obj !== null && typeof obj === 'object'; 10752} // KeyboardEvent.keyCode aliases 10753 10754const keyCodes = Object.freeze({ 10755 enter: 13, 10756 tab: 9, 10757 delete: 46, 10758 esc: 27, 10759 space: 32, 10760 up: 38, 10761 down: 40, 10762 left: 37, 10763 right: 39, 10764 end: 35, 10765 home: 36, 10766 del: 46, 10767 backspace: 8, 10768 insert: 45, 10769 pageup: 33, 10770 pagedown: 34, 10771 shift: 16 10772}); 10773/** 10774 * This remaps internal names like '$cancel' or '$vuetify.icons.cancel' 10775 * to the current name or component for that icon. 10776 */ 10777 10778function remapInternalIcon(vm, iconName) { 10779 // Look for custom component in the configuration 10780 const component = vm.$vuetify.icons.component; // Look for overrides 10781 10782 if (iconName.startsWith('$')) { 10783 // Get the target icon name 10784 const iconPath = `$vuetify.icons.values.${iconName.split('$').pop().split('.').pop()}`; // Now look up icon indirection name, 10785 // e.g. '$vuetify.icons.values.cancel' 10786 10787 const override = getObjectValueByPath(vm, iconPath, iconName); 10788 if (typeof override === 'string') iconName = override;else return override; 10789 } 10790 if (component == null) { 10791 return iconName; 10792 } 10793 return { 10794 component, 10795 props: { 10796 icon: iconName 10797 } 10798 }; 10799} 10800function keys(o) { 10801 return Object.keys(o); 10802} 10803/** 10804 * Camelize a hyphen-delimited string. 10805 */ 10806 10807const camelizeRE = /-(\w)/g; 10808const camelize = str => { 10809 return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ''); 10810}; 10811/** 10812 * Returns the set difference of B and A, i.e. the set of elements in B but not in A 10813 */ 10814 10815function arrayDiff(a, b) { 10816 const diff = []; 10817 for (let i = 0; i < b.length; i++) { 10818 if (a.indexOf(b[i]) < 0) diff.push(b[i]); 10819 } 10820 return diff; 10821} 10822/** 10823 * Makes the first character of a string uppercase 10824 */ 10825 10826function upperFirst(str) { 10827 return str.charAt(0).toUpperCase() + str.slice(1); 10828} 10829function groupItems(items, groupBy, groupDesc) { 10830 const key = groupBy[0]; 10831 const groups = []; 10832 let current; 10833 for (let i = 0; i < items.length; i++) { 10834 const item = items[i]; 10835 const val = getObjectValueByPath(item, key, null); 10836 if (current !== val) { 10837 current = val; 10838 groups.push({ 10839 name: val !== null && val !== void 0 ? val : '', 10840 items: [] 10841 }); 10842 } 10843 groups[groups.length - 1].items.push(item); 10844 } 10845 return groups; 10846} 10847function wrapInArray(v) { 10848 return v != null ? Array.isArray(v) ? v : [v] : []; 10849} 10850function sortItems(items, sortBy, sortDesc, locale, customSorters) { 10851 if (sortBy === null || !sortBy.length) return items; 10852 const stringCollator = new Intl.Collator(locale, { 10853 sensitivity: 'accent', 10854 usage: 'sort' 10855 }); 10856 return items.sort((a, b) => { 10857 for (let i = 0; i < sortBy.length; i++) { 10858 const sortKey = sortBy[i]; 10859 let sortA = getObjectValueByPath(a, sortKey); 10860 let sortB = getObjectValueByPath(b, sortKey); 10861 if (sortDesc[i]) { 10862 var _ref2 = [sortB, sortA]; 10863 sortA = _ref2[0]; 10864 sortB = _ref2[1]; 10865 } 10866 if (customSorters && customSorters[sortKey]) { 10867 const customResult = customSorters[sortKey](sortA, sortB); 10868 if (!customResult) continue; 10869 return customResult; 10870 } // Check if both cannot be evaluated 10871 10872 if (sortA === null && sortB === null) { 10873 continue; 10874 } // Dates should be compared numerically 10875 10876 if (sortA instanceof Date && sortB instanceof Date) { 10877 return sortA.getTime() - sortB.getTime(); 10878 } 10879 var _map = [sortA, sortB].map(s => (s || '').toString().toLocaleLowerCase()); 10880 var _map2 = _slicedToArray(_map, 2); 10881 sortA = _map2[0]; 10882 sortB = _map2[1]; 10883 if (sortA !== sortB) { 10884 if (!isNaN(sortA) && !isNaN(sortB)) return Number(sortA) - Number(sortB); 10885 return stringCollator.compare(sortA, sortB); 10886 } 10887 } 10888 return 0; 10889 }); 10890} 10891function defaultFilter(value, search, item) { 10892 return value != null && search != null && typeof value !== 'boolean' && value.toString().toLocaleLowerCase().indexOf(search.toLocaleLowerCase()) !== -1; 10893} 10894function searchItems(items, search) { 10895 if (!search) return items; 10896 search = search.toString().toLowerCase(); 10897 if (search.trim() === '') return items; 10898 return items.filter(item => Object.keys(item).some(key => defaultFilter(getObjectValueByPath(item, key), search, item))); 10899} 10900/** 10901 * Returns: 10902 * - 'normal' for old style slots - `<template slot="default">` 10903 * - 'scoped' for old style scoped slots (`<template slot="default" slot-scope="data">`) or bound v-slot (`#default="data"`) 10904 * - 'v-slot' for unbound v-slot (`#default`) - only if the third param is true, otherwise counts as scoped 10905 */ 10906 10907function getSlotType(vm, name, split) { 10908 if (vm.$slots.hasOwnProperty(name) && vm.$scopedSlots.hasOwnProperty(name) && vm.$scopedSlots[name].name) { 10909 return split ? 'v-slot' : 'scoped'; 10910 } 10911 if (vm.$slots.hasOwnProperty(name)) return 'normal'; 10912 if (vm.$scopedSlots.hasOwnProperty(name)) return 'scoped'; 10913} 10914function debounce(fn, delay) { 10915 let timeoutId = 0; 10916 return function () { 10917 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 10918 args[_key] = arguments[_key]; 10919 } 10920 clearTimeout(timeoutId); 10921 timeoutId = setTimeout(() => fn(...args), delay); 10922 }; 10923} 10924function throttle(fn, limit) { 10925 let throttling = false;
10926 return function () { 10927 if (!throttling) { 10928 throttling = true; 10929 setTimeout(() => throttling = false, limit); 10930 return fn(...arguments); 10931 } 10932 }; 10933} 10934function getPrefixedScopedSlots(prefix, scopedSlots) { 10935 return Object.keys(scopedSlots).filter(k => k.startsWith(prefix)).reduce((obj, k) => { 10936 obj[k.replace(prefix, '')] = scopedSlots[k]; 10937 return obj; 10938 }, {}); 10939} 10940function getSlot(vm) { 10941 let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default'; 10942 let data = arguments.length > 2 ? arguments[2] : undefined; 10943 let optional = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; 10944 if (vm.$scopedSlots.hasOwnProperty(name)) { 10945 return vm.$scopedSlots[name](data instanceof Function ? data() : data); 10946 } else if (vm.$slots.hasOwnProperty(name) && (!data || optional)) { 10947 return vm.$slots[name]; 10948 } 10949 return undefined; 10950} 10951function clamp(value) { 10952 let min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 10953 let max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; 10954 return Math.max(min, Math.min(max, value)); 10955} 10956function padEnd(str, length) { 10957 let char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0'; 10958 return str + char.repeat(Math.max(0, length - str.length)); 10959} 10960function chunk(str) { 10961 let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; 10962 const chunked = []; 10963 let index = 0; 10964 while (index < str.length) { 10965 chunked.push(str.substr(index, size)); 10966 index += size; 10967 } 10968 return chunked; 10969} 10970function humanReadableFileSize(bytes) { 10971 let binary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 10972 const base = binary ? 1024 : 1000; 10973 if (bytes < base) { 10974 return `${bytes} B`; 10975 } 10976 const prefix = binary ? ['Ki', 'Mi', 'Gi'] : ['k', 'M', 'G']; 10977 let unit = -1; 10978 while (Math.abs(bytes) >= base && unit < prefix.length - 1) { 10979 bytes /= base; 10980 ++unit; 10981 } 10982 return `${bytes.toFixed(1)} ${prefix[unit]}B`; 10983} 10984function camelizeObjectKeys(obj) { 10985 if (!obj) return {}; 10986 return Object.keys(obj).reduce((o, key) => { 10987 o[camelize(key)] = obj[key]; 10988 return o; 10989 }, {}); 10990} 10991function mergeDeep() { 10992 let source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; 10993 let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; 10994 for (const key in target) { 10995 const sourceProperty = source[key]; 10996 const targetProperty = target[key]; // Only continue deep merging if 10997 // both properties are objects 10998 10999 if (isObject(sourceProperty) && isObject(targetProperty)) { 11000 source[key] = mergeDeep(sourceProperty, targetProperty); 11001 continue; 11002 } 11003 source[key] = targetProperty; 11004 } 11005 return source; 11006} 11007function fillArray(length, obj) { 11008 return Array(length).fill(obj); 11009} 11010/** Polyfill for Event.prototype.composedPath */ 11011 11012function composedPath(e) { 11013 if (e.composedPath) return e.composedPath(); 11014 const path = []; 11015 let el = e.target; 11016 while (el) { 11017 path.push(el); 11018 if (el.tagName === 'HTML') { 11019 path.push(document); 11020 path.push(window); 11021 return path; 11022 } 11023 el = el.parentElement; 11024 } 11025 return path; 11026} 11027 11028/***/ }), 11029 11030/***/ 8097: 11031/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 11032 11033"use strict"; 11034/* harmony export */ __webpack_require__.d(__webpack_exports__, { 11035/* harmony export */ ZP: function() { return /* binding */ mergeData; }, 11036/* harmony export */ bp: function() { return /* binding */ mergeListeners; } 11037/* harmony export */ }); 11038/* unused harmony exports mergeStyles, mergeClasses */ 11039/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1180); 11040/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1181); 11041/* harmony import */ var core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_web_dom_iterable__WEBPACK_IMPORTED_MODULE_0__); 11042/* harmony import */ var D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_slicedToArray_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7625); 11043/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1876); 11044/* harmony import */ var core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_js_modules_es6_regexp_split__WEBPACK_IMPORTED_MODULE_1__); 11045/* harmony import */ var _helpers__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6539); 11046 11047 11048 11049 11050function 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; } 11051function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {};
11051 r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_defineProperty_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(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; } 11052 11053const pattern = { 11054 styleList: /;(?![^(]*\))/g, 11055 styleProp: /:(.*)/ 11056}; 11057function parseStyle(style) { 11058 const styleMap = {}; 11059 for (const s of style.split(pattern.styleList)) { 11060 let _s$split = s.split(pattern.styleProp), 11061 _s$split2 = (0,D_WEB_FREEBOX_assistant_v14_node_modules_babel_runtime_helpers_esm_slicedToArray_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(_s$split, 2), 11062 key = _s$split2[0], 11063 val = _s$split2[1]; 11064 key = key.trim(); 11065 if (!key) { 11066 continue; 11067 } // May be undefined if the `key: value` pair is incomplete. 11068 11069 if (typeof val === 'string') { 11070 val = val.trim(); 11071 } 11072 styleMap[(0,_helpers__WEBPACK_IMPORTED_MODULE_4__/* .camelize */ ._A)(key)] = val; 11073 } 11074 return styleMap; 11075} 11076function mergeData() { 11077 const mergeTarget = {}; 11078 let i = arguments.length; 11079 let prop; // Allow for variadic argument length. 11080 11081 while (i--) { 11082 // Iterate through the data properties and execute merge strategies 11083 // Object.keys eliminates need for hasOwnProperty call 11084 for (prop of Object.keys(arguments[i])) { 11085 switch (prop) { 11086 // Array merge strategy (array concatenation) 11087 case 'class': 11088 case 'directives': 11089 if (arguments[i][prop]) { 11090 mergeTarget[prop] = mergeClasses(mergeTarget[prop], arguments[i][prop]); 11091 } 11092 break; 11093 case 'style': 11094 if (arguments[i][prop]) { 11095 mergeTarget[prop] = mergeStyles(mergeTarget[prop], arguments[i][prop]); 11096 } 11097 break; 11098 // Space delimited string concatenation strategy 11099 11100 case 'staticClass': 11101 if (!arguments[i][prop]) { 11102 break; 11103 } 11104 if (mergeTarget[prop] === undefined) { 11105 mergeTarget[prop] = ''; 11106 } 11107 if (mergeTarget[prop]) { 11108 // Not an empty string, so concatenate 11109 mergeTarget[prop] += ' '; 11110 } 11111 mergeTarget[prop] += arguments[i][prop].trim(); 11112 break; 11113 // Object, the properties of which to merge via array merge strategy (array concatenation). 11114 // Callback merge strategy merges callbacks to the beginning of the array, 11115 // so that the last defined callback will be invoked first. 11116 // This is done since to mimic how Object.assign merging 11117 // uses the last given value to assign. 11118 11119 case 'on': 11120 case 'nativeOn': 11121 if (arguments[i][prop]) { 11122 mergeTarget[prop] = mergeListeners(mergeTarget[prop], arguments[i][prop]); 11123 } 11124 break; 11125 // Object merge strategy 11126 11127 case 'attrs': 11128 case 'props': 11129 case 'domProps': 11130 case 'scopedSlots': 11131 case 'staticStyle': 11132 case 'hook': 11133 case 'transition': 11134 if (!arguments[i][prop]) { 11135 break; 11136 } 11137 if (!mergeTarget[prop]) { 11138 mergeTarget[prop] = {}; 11139 } 11140 mergeTarget[prop] = _objectSpread(_objectSpread({}, arguments[i][prop]), mergeTarget[prop]); 11141 break; 11142 // Reassignment strategy (no merge) 11143 11144 default: 11145 // slot, key, ref, tag, show, keepAlive 11146 if (!mergeTarget[prop]) { 11147 mergeTarget[prop] = arguments[i][prop]; 11148 } 11149 } 11150 } 11151 } 11152 return mergeTarget; 11153} 11154function mergeStyles(target, source) { 11155 if (!target) return source; 11156 if (!source) return target; 11157 target = (0,_helpers__WEBPACK_IMPORTED_MODULE_4__/* .wrapInArray */ .TI)(typeof target === 'string' ? parseStyle(target) : target); 11158 return target.concat(typeof source === 'string' ? parseStyle(source) : source); 11159} 11160function mergeClasses(target, source) { 11161 if (!source) return target; 11162 if (!target) return source; 11163 return target ? (0,_helpers__WEBPACK_IMPORTED_MODULE_4__/* .wrapInArray */ .TI)(target).concat(source) : source; 11164} 11165function mergeListeners() { 11166 if (!(arguments.length <= 0 ? undefined : arguments[0])) return arguments.length <= 1 ? undefined : arguments[1]; 11167 if (!(arguments.length <= 1 ? undefined : arguments[1])) return arguments.length <= 0 ? undefined : arguments[0]; 11168 const dest = {}; 11169 for (let i = 2; i--;) { 11170 const arg = i < 0 || arguments.length <= i ? undefined : arguments[i]; 11171 for (const event in arg) { 11172 if (!arg[event]) continue; 11173 if (dest[event]) { 11174 // Merge current listeners before (because we are iterating backwards). 11175 // Note that neither "target" or "source" must be altered. 11176 dest[event] = [].concat(arg[event], dest[event]); 11177 } else { 11178 // Straight assign. 11179 dest[event] = arg[event]; 11180 } 11181 } 11182 } 11183 return dest; 11184} 11185
vendor: 18,736 bytes, lines 11186-11849
11186/***/ }), 11187 11188/***/ 9547: 11189/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 11190 11191"use strict"; 11192/* harmony export */ __webpack_require__.d(__webpack_exports__, { 11193/* harmony export */ Z: function() { return /* binding */ mixins; } 11194/* harmony export */ }); 11195/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(538); 11196/* eslint-disable max-len, import/export, no-use-before-define */ 11197 11198function mixins() { 11199 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 11200 args[_key] = arguments[_key]; 11201 } 11202 return vue__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP.extend({ 11203 mixins: args 11204 }); 11205} 11206 11207/***/ }), 11208 11209/***/ 4963: 11210/***/ (function(module) { 11211 11212module.exports = function (it) { 11213 if (typeof it != 'function') throw TypeError(it + ' is not a function!'); 11214 return it; 11215}; 11216 11217 11218/***/ }), 11219 11220/***/ 7722: 11221/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11222 11223// 22.1.3.31 Array.prototype[@@unscopables] 11224var UNSCOPABLES = __webpack_require__(6314)('unscopables'); 11225var ArrayProto = Array.prototype; 11226if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(7728)(ArrayProto, UNSCOPABLES, {}); 11227module.exports = function (key) { 11228 ArrayProto[UNSCOPABLES][key] = true; 11229}; 11230 11231 11232/***/ }), 11233 11234/***/ 6793: 11235/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11236 11237"use strict"; 11238 11239var at = __webpack_require__(4496)(true); 11240 11241 // `AdvanceStringIndex` abstract operation 11242// https://tc39.github.io/ecma262/#sec-advancestringindex 11243module.exports = function (S, index, unicode) { 11244 return index + (unicode ? at(S, index).length : 1); 11245}; 11246 11247 11248/***/ }), 11249 11250/***/ 7007: 11251/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11252 11253var isObject = __webpack_require__(5286); 11254module.exports = function (it) { 11255 if (!isObject(it)) throw TypeError(it + ' is not an object!'); 11256 return it; 11257}; 11258 11259 11260/***/ }), 11261 11262/***/ 9315: 11263/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11264 11265// false -> Array#indexOf 11266// true -> Array#includes 11267var toIObject = __webpack_require__(2110); 11268var toLength = __webpack_require__(875); 11269var toAbsoluteIndex = __webpack_require__(2337); 11270module.exports = function (IS_INCLUDES) { 11271 return function ($this, el, fromIndex) { 11272 var O = toIObject($this); 11273 var length = toLength(O.length); 11274 var index = toAbsoluteIndex(fromIndex, length); 11275 var value; 11276 // Array#includes uses SameValueZero equality algorithm 11277 // eslint-disable-next-line no-self-compare 11278 if (IS_INCLUDES && el != el) while (length > index) { 11279 value = O[index++]; 11280 // eslint-disable-next-line no-self-compare 11281 if (value != value) return true; 11282 // Array#indexOf ignores holes, Array#includes - not 11283 } else for (;length > index; index++) if (IS_INCLUDES || index in O) { 11284 if (O[index] === el) return IS_INCLUDES || index || 0; 11285 } return !IS_INCLUDES && -1; 11286 }; 11287}; 11288 11289 11290/***/ }), 11291 11292/***/ 1488: 11293/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11294 11295// getting tag from 19.1.3.6 Object.prototype.toString() 11296var cof = __webpack_require__(2032); 11297var TAG = __webpack_require__(6314)('toStringTag'); 11298// ES3 wrong here 11299var ARG = cof(function () { return arguments; }()) == 'Arguments'; 11300 11301// fallback for IE11 Script Access Denied error 11302var tryGet = function (it, key) { 11303 try { 11304 return it[key]; 11305 } catch (e) { /* empty */ } 11306}; 11307 11308module.exports = function (it) { 11309 var O, T, B; 11310 return it === undefined ? 'Undefined' : it === null ? 'Null' 11311 // @@toStringTag case 11312 : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T 11313 // builtinTag case 11314 : ARG ? cof(O) 11315 // ES3 arguments fallback 11316 : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; 11317}; 11318 11319 11320/***/ }), 11321 11322/***/ 2032: 11323/***/ (function(module) { 11324 11325var toString = {}.toString; 11326 11327module.exports = function (it) { 11328 return toString.call(it).slice(8, -1); 11329}; 11330 11331 11332/***/ }), 11333 11334/***/ 5645: 11335/***/ (function(module) { 11336 11337var core = module.exports = { version: '2.6.12' }; 11338if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef 11339 11340 11341/***/ }), 11342 11343/***/ 741: 11344/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11345 11346// optional / simple context binding 11347var aFunction = __webpack_require__(4963); 11348module.exports = function (fn, that, length) { 11349 aFunction(fn); 11350 if (that === undefined) return fn; 11351 switch (length) { 11352 case 1: return function (a) { 11353 return fn.call(that, a); 11354 }; 11355 case 2: return function (a, b) { 11356 return fn.call(that, a, b); 11357 }; 11358 case 3: return function (a, b, c) { 11359 return fn.call(that, a, b, c); 11360 }; 11361 } 11362 return function (/* ...args */) { 11363 return fn.apply(that, arguments); 11364 }; 11365}; 11366 11367 11368/***/ }), 11369 11370/***/ 1355: 11371/***/ (function(module) { 11372 11373// 7.2.1 RequireObjectCoercible(argument) 11374module.exports = function (it) { 11375 if (it == undefined) throw TypeError("Can't call method on " + it); 11376 return it; 11377}; 11378 11379 11380/***/ }), 11381 11382/***/ 7057: 11383/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11384 11385// Thank's IE8 for his funny defineProperty 11386module.exports = !__webpack_require__(4253)(function () { 11387 return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; 11388}); 11389 11390 11391/***/ }), 11392 11393/***/ 2457: 11394/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11395 11396var isObject = __webpack_require__(5286); 11397var document = (__webpack_require__(3816).document); 11398// typeof document.createElement is 'object' in old IE 11399var is = isObject(document) && isObject(document.createElement); 11400module.exports = function (it) { 11401 return is ? document.createElement(it) : {}; 11402}; 11403 11404 11405/***/ }), 11406 11407/***/ 4430: 11408/***/ (function(module) { 11409 11410// IE 8- don't enum bug keys 11411module.exports = ( 11412 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' 11413).split(','); 11414 11415 11416/***/ }), 11417 11418/***/ 5541: 11419/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11420 11421// all enumerable object keys, includes symbols 11422var getKeys = __webpack_require__(7184); 11423var gOPS = __webpack_require__(4548); 11424var pIE = __webpack_require__(4682); 11425module.exports = function (it) { 11426 var result = getKeys(it); 11427 var getSymbols = gOPS.f; 11428 if (getSymbols) { 11429 var symbols = getSymbols(it); 11430 var isEnum = pIE.f; 11431 var i = 0; 11432 var key; 11433 while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key); 11434 } return result; 11435}; 11436 11437 11438/***/ }), 11439 11440/***/ 2985: 11441/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11442 11443var global = __webpack_require__(3816); 11444var core = __webpack_require__(5645); 11445var hide = __webpack_require__(7728); 11446var redefine = __webpack_require__(3415); 11447var ctx = __webpack_require__(741); 11448var PROTOTYPE = 'prototype'; 11449 11450var $export = function (type, name, source) { 11451 var IS_FORCED = type & $export.F; 11452 var IS_GLOBAL = type & $export.G; 11453 var IS_STATIC = type & $export.S; 11454 var IS_PROTO = type & $export.P; 11455 var IS_BIND = type & $export.B; 11456 var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]; 11457 var exports = IS_GLOBAL ? core : core[name] || (core[name] = {}); 11458 var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); 11459 var key, own, out, exp; 11460 if (IS_GLOBAL) source = name; 11461 for (key in source) { 11462 // contains in native 11463 own = !IS_FORCED && target && target[key] !== undefined; 11464 // export native or passed 11465 out = (own ? target : source)[key]; 11466 // bind timers to global for call from export context 11467 exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; 11468 // extend global 11469 if (target) redefine(target, key, out, type & $export.U); 11470 // export 11471 if (exports[key] != out) hide(exports, key, exp); 11472 if (IS_PROTO && expProto[key] != out) expProto[key] = out; 11473 } 11474}; 11475global.core = core; 11476// type bitmap 11477$export.F = 1; // forced 11478$export.G = 2; // global 11479$export.S = 4; // static 11480$export.P = 8; // proto 11481$export.B = 16; // bind 11482$export.W = 32; // wrap 11483$export.U = 64; // safe 11484$export.R = 128; // real proto method for `library` 11485module.exports = $export; 11486 11487 11488/***/ }), 11489 11490/***/ 8852: 11491/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11492 11493var MATCH = __webpack_require__(6314)('match'); 11494module.exports = function (KEY) { 11495 var re = /./; 11496 try { 11497 '/./'[KEY](re); 11498 } catch (e) { 11499 try { 11500 re[MATCH] = false; 11501 return !'/./'[KEY](re); 11502 } catch (f) { /* empty */ } 11503 } return true; 11504}; 11505 11506 11507/***/ }), 11508 11509/***/ 4253: 11510/***/ (function(module) { 11511 11512module.exports = function (exec) { 11513 try { 11514 return !!exec(); 11515 } catch (e) { 11516 return true; 11517 } 11518}; 11519 11520 11521/***/ }), 11522 11523/***/ 8082: 11524/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11525 11526"use strict"; 11527 11528__webpack_require__(8269); 11529var redefine = __webpack_require__(3415); 11530var hide = __webpack_require__(7728); 11531var fails = __webpack_require__(4253); 11532var defined = __webpack_require__(1355); 11533var wks = __webpack_require__(6314); 11534var regexpExec = __webpack_require__(1165); 11535 11536var SPECIES = wks('species'); 11537 11538var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { 11539 // #replace needs built-in support for named groups. 11540 // #match works fine because it just return the exec results, even if it has 11541 // a "grops" property. 11542 var re = /./; 11543 re.exec = function () { 11544 var result = []; 11545 result.groups = { a: '7' }; 11546 return result; 11547 }; 11548 return ''.replace(re, '$<a>') !== '7'; 11549}); 11550 11551var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () { 11552 // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec 11553 var re = /(?:)/; 11554 var originalExec = re.exec; 11555 re.exec = function () { return originalExec.apply(this, arguments); }; 11556 var result = 'ab'.split(re); 11557 return result.length === 2 && result[0] === 'a' && result[1] === 'b'; 11558})(); 11559 11560module.exports = function (KEY, length, exec) { 11561 var SYMBOL = wks(KEY); 11562 11563 var DELEGATES_TO_SYMBOL = !fails(function () { 11564 // String methods call symbol-named RegEp methods 11565 var O = {}; 11566 O[SYMBOL] = function () { return 7; }; 11567 return ''[KEY](O) != 7; 11568 }); 11569 11570 var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () { 11571 // Symbol-named RegExp methods call .exec 11572 var execCalled = false; 11573 var re = /a/; 11574 re.exec = function () { execCalled = true; return null; }; 11575 if (KEY === 'split') { 11576 // RegExp[@@split] doesn't call the regex's exec method, but first creates 11577 // a new one. We need to return the patched regex when creating the new one. 11578 re.constructor = {}; 11579 re.constructor[SPECIES] = function () { return re; }; 11580 } 11581 re[SYMBOL](''); 11582 return !execCalled; 11583 }) : undefined; 11584 11585 if ( 11586 !DELEGATES_TO_SYMBOL || 11587 !DELEGATES_TO_EXEC || 11588 (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || 11589 (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) 11590 ) { 11591 var nativeRegExpMethod = /./[SYMBOL]; 11592 var fns = exec( 11593 defined, 11594 SYMBOL, 11595 ''[KEY], 11596 function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) { 11597 if (regexp.exec === regexpExec) { 11598 if (DELEGATES_TO_SYMBOL && !forceStringMethod) { 11599 // The native String method already delegates to @@method (this 11600 // polyfilled function), leasing to infinite recursion. 11601 // We avoid it by directly calling the native @@method method. 11602 return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; 11603 } 11604 return { done: true, value: nativeMethod.call(str, regexp, arg2) }; 11605 } 11606 return { done: false }; 11607 } 11608 ); 11609 var strfn = fns[0]; 11610 var rxfn = fns[1]; 11611 11612 redefine(String.prototype, KEY, strfn); 11613 hide(RegExp.prototype, SYMBOL, length == 2 11614 // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue) 11615 // 21.2.5.11 RegExp.prototype[@@split](string, limit) 11616 ? function (string, arg) { return rxfn.call(string, this, arg); } 11617 // 21.2.5.6 RegExp.prototype[@@match](string) 11618 // 21.2.5.9 RegExp.prototype[@@search](string) 11619 : function (string) { return rxfn.call(string, this); } 11620 ); 11621 } 11622}; 11623 11624 11625/***/ }), 11626 11627/***/ 3218: 11628/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11629 11630"use strict"; 11631 11632// 21.2.5.3 get RegExp.prototype.flags 11633var anObject = __webpack_require__(7007); 11634module.exports = function () { 11635 var that = anObject(this); 11636 var result = ''; 11637 if (that.global) result += 'g'; 11638 if (that.ignoreCase) result += 'i'; 11639 if (that.multiline) result += 'm'; 11640 if (that.unicode) result += 'u'; 11641 if (that.sticky) result += 'y'; 11642 return result; 11643}; 11644 11645 11646/***/ }), 11647 11648/***/ 18: 11649/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11650 11651module.exports = __webpack_require__(3825)('native-function-to-string', Function.toString); 11652 11653 11654/***/ }), 11655 11656/***/ 3816: 11657/***/ (function(module) { 11658 11659// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 11660var global = module.exports = typeof window != 'undefined' && window.Math == Math 11661 ? window : typeof self != 'undefined' && self.Math == Math ? self 11662 // eslint-disable-next-line no-new-func 11663 : Function('return this')(); 11664if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef 11665 11666 11667/***/ }), 11668 11669/***/ 9181: 11670/***/ (function(module) { 11671 11672var hasOwnProperty = {}.hasOwnProperty; 11673module.exports = function (it, key) { 11674 return hasOwnProperty.call(it, key); 11675}; 11676 11677 11678/***/ }), 11679 11680/***/ 7728: 11681/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11682 11683var dP = __webpack_require__(9275); 11684var createDesc = __webpack_require__(681); 11685module.exports = __webpack_require__(7057) ? function (object, key, value) { 11686 return dP.f(object, key, createDesc(1, value)); 11687} : function (object, key, value) { 11688 object[key] = value; 11689 return object; 11690}; 11691 11692 11693/***/ }), 11694 11695/***/ 639: 11696/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11697 11698var document = (__webpack_require__(3816).document); 11699module.exports = document && document.documentElement; 11700 11701 11702/***/ }), 11703 11704/***/ 1734: 11705/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11706 11707module.exports = !__webpack_require__(7057) && !__webpack_require__(4253)(function () { 11708 return Object.defineProperty(__webpack_require__(2457)('div'), 'a', { get: function () { return 7; } }).a != 7; 11709}); 11710 11711 11712/***/ }), 11713 11714/***/ 9797: 11715/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11716 11717// fallback for non-array-like ES3 and non-enumerable old V8 strings 11718var cof = __webpack_require__(2032); 11719// eslint-disable-next-line no-prototype-builtins 11720module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) { 11721 return cof(it) == 'String' ? it.split('') : Object(it); 11722}; 11723 11724 11725/***/ }), 11726 11727/***/ 4302: 11728/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11729 11730// 7.2.2 IsArray(argument) 11731var cof = __webpack_require__(2032); 11732module.exports = Array.isArray || function isArray(arg) { 11733 return cof(arg) == 'Array'; 11734}; 11735 11736 11737/***/ }), 11738 11739/***/ 5286: 11740/***/ (function(module) { 11741 11742module.exports = function (it) { 11743 return typeof it === 'object' ? it !== null : typeof it === 'function'; 11744}; 11745 11746 11747/***/ }), 11748 11749/***/ 5364: 11750/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11751 11752// 7.2.8 IsRegExp(argument) 11753var isObject = __webpack_require__(5286); 11754var cof = __webpack_require__(2032); 11755var MATCH = __webpack_require__(6314)('match'); 11756module.exports = function (it) { 11757 var isRegExp; 11758 return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp'); 11759}; 11760 11761 11762/***/ }), 11763 11764/***/ 9988: 11765/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11766 11767"use strict"; 11768 11769var create = __webpack_require__(2503); 11770var descriptor = __webpack_require__(681); 11771var setToStringTag = __webpack_require__(2943); 11772var IteratorPrototype = {}; 11773 11774// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() 11775__webpack_require__(7728)(IteratorPrototype, __webpack_require__(6314)('iterator'), function () { return this; }); 11776 11777module.exports = function (Constructor, NAME, next) { 11778 Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) }); 11779 setToStringTag(Constructor, NAME + ' Iterator'); 11780}; 11781 11782 11783/***/ }), 11784 11785/***/ 2923: 11786/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11787 11788"use strict"; 11789 11790var LIBRARY = __webpack_require__(4461); 11791var $export = __webpack_require__(2985); 11792var redefine = __webpack_require__(3415); 11793var hide = __webpack_require__(7728); 11794var Iterators = __webpack_require__(7234); 11795var $iterCreate = __webpack_require__(9988); 11796var setToStringTag = __webpack_require__(2943); 11797var getPrototypeOf = __webpack_require__(468); 11798var ITERATOR = __webpack_require__(6314)('iterator'); 11799var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next` 11800var FF_ITERATOR = '@@iterator'; 11801var KEYS = 'keys'; 11802var VALUES = 'values'; 11803 11804var returnThis = function () { return this; }; 11805 11806module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { 11807 $iterCreate(Constructor, NAME, next); 11808 var getMethod = function (kind) { 11809 if (!BUGGY && kind in proto) return proto[kind]; 11810 switch (kind) { 11811 case KEYS: return function keys() { return new Constructor(this, kind); }; 11812 case VALUES: return function values() { return new Constructor(this, kind); }; 11813 } return function entries() { return new Constructor(this, kind); }; 11814 }; 11815 var TAG = NAME + ' Iterator'; 11816 var DEF_VALUES = DEFAULT == VALUES; 11817 var VALUES_BUG = false; 11818 var proto = Base.prototype; 11819 var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; 11820 var $default = $native || getMethod(DEFAULT); 11821 var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined; 11822 var $anyNative = NAME == 'Array' ? proto.entries || $native : $native; 11823 var methods, key, IteratorPrototype; 11824 // Fix native 11825 if ($anyNative) { 11826 IteratorPrototype = getPrototypeOf($anyNative.call(new Base())); 11827 if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { 11828 // Set @@toStringTag to native iterators 11829 setToStringTag(IteratorPrototype, TAG, true); 11830 // fix for some old engines 11831 if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis); 11832 } 11833 } 11834 // fix Array#{values, @@iterator}.name in V8 / FF 11835 if (DEF_VALUES && $native && $native.name !== VALUES) { 11836 VALUES_BUG = true; 11837 $default = function values() { return $native.call(this); }; 11838 } 11839 // Define iterator 11840 if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { 11841 hide(proto, ITERATOR, $default); 11842 } 11843 // Plug for library 11844 Iterators[NAME] = $default; 11845 Iterators[TAG] = returnThis; 11846 if (DEFAULT) { 11847 methods = { 11848 values: DEF_VALUES ? $default : getMethod(VALUES), 11849 keys: IS_SET ? $default : getMethod(KEYS),
vendor: 6,816 bytes, lines 11850-12102
11850 entries: $entries 11851 }; 11852 if (FORCED) for (key in methods) { 11853 if (!(key in proto)) redefine(proto, key, methods[key]); 11854 } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); 11855 } 11856 return methods; 11857}; 11858 11859 11860/***/ }), 11861 11862/***/ 5436: 11863/***/ (function(module) { 11864 11865module.exports = function (done, value) { 11866 return { value: value, done: !!done }; 11867}; 11868 11869 11870/***/ }), 11871 11872/***/ 7234: 11873/***/ (function(module) { 11874 11875module.exports = {}; 11876 11877 11878/***/ }), 11879 11880/***/ 4461: 11881/***/ (function(module) { 11882 11883module.exports = false; 11884 11885 11886/***/ }), 11887 11888/***/ 4728: 11889/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11890 11891var META = __webpack_require__(3953)('meta'); 11892var isObject = __webpack_require__(5286); 11893var has = __webpack_require__(9181); 11894var setDesc = (__webpack_require__(9275).f); 11895var id = 0; 11896var isExtensible = Object.isExtensible || function () { 11897 return true; 11898}; 11899var FREEZE = !__webpack_require__(4253)(function () { 11900 return isExtensible(Object.preventExtensions({})); 11901}); 11902var setMeta = function (it) { 11903 setDesc(it, META, { value: { 11904 i: 'O' + ++id, // object ID 11905 w: {} // weak collections IDs 11906 } }); 11907}; 11908var fastKey = function (it, create) { 11909 // return primitive with prefix 11910 if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; 11911 if (!has(it, META)) { 11912 // can't set metadata to uncaught frozen object 11913 if (!isExtensible(it)) return 'F'; 11914 // not necessary to add metadata 11915 if (!create) return 'E'; 11916 // add missing metadata 11917 setMeta(it); 11918 // return object ID 11919 } return it[META].i; 11920}; 11921var getWeak = function (it, create) { 11922 if (!has(it, META)) { 11923 // can't set metadata to uncaught frozen object 11924 if (!isExtensible(it)) return true; 11925 // not necessary to add metadata 11926 if (!create) return false; 11927 // add missing metadata 11928 setMeta(it); 11929 // return hash weak collections IDs 11930 } return it[META].w; 11931}; 11932// add metadata on freeze-family methods calling 11933var onFreeze = function (it) { 11934 if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it); 11935 return it; 11936}; 11937var meta = module.exports = { 11938 KEY: META, 11939 NEED: false, 11940 fastKey: fastKey, 11941 getWeak: getWeak, 11942 onFreeze: onFreeze 11943}; 11944 11945 11946/***/ }), 11947 11948/***/ 2503: 11949/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 11950 11951// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) 11952var anObject = __webpack_require__(7007); 11953var dPs = __webpack_require__(5588); 11954var enumBugKeys = __webpack_require__(4430); 11955var IE_PROTO = __webpack_require__(9335)('IE_PROTO'); 11956var Empty = function () { /* empty */ }; 11957var PROTOTYPE = 'prototype'; 11958 11959// Create object with fake `null` prototype: use iframe Object with cleared prototype 11960var createDict = function () { 11961 // Thrash, waste and sodomy: IE GC bug 11962 var iframe = __webpack_require__(2457)('iframe'); 11963 var i = enumBugKeys.length; 11964 var lt = '<'; 11965 var gt = '>'; 11966 var iframeDocument; 11967 iframe.style.display = 'none'; 11968 (__webpack_require__(639).appendChild)(iframe); 11969 iframe.src = 'javascript:'; // eslint-disable-line no-script-url 11970 // createDict = iframe.contentWindow.Object; 11971 // html.removeChild(iframe); 11972 iframeDocument = iframe.contentWindow.document; 11973 iframeDocument.open(); 11974 iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); 11975 iframeDocument.close(); 11976 createDict = iframeDocument.F; 11977 while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]]; 11978 return createDict(); 11979}; 11980 11981module.exports = Object.create || function create(O, Properties) { 11982 var result; 11983 if (O !== null) { 11984 Empty[PROTOTYPE] = anObject(O); 11985 result = new Empty(); 11986 Empty[PROTOTYPE] = null; 11987 // add "__proto__" for Object.getPrototypeOf polyfill 11988 result[IE_PROTO] = O; 11989 } else result = createDict(); 11990 return Properties === undefined ? result : dPs(result, Properties); 11991}; 11992 11993 11994/***/ }), 11995 11996/***/ 9275: 11997/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 11998 11999var anObject = __webpack_require__(7007); 12000var IE8_DOM_DEFINE = __webpack_require__(1734); 12001var toPrimitive = __webpack_require__(1689); 12002var dP = Object.defineProperty; 12003 12004exports.f = __webpack_require__(7057) ? Object.defineProperty : function defineProperty(O, P, Attributes) { 12005 anObject(O); 12006 P = toPrimitive(P, true); 12007 anObject(Attributes); 12008 if (IE8_DOM_DEFINE) try { 12009 return dP(O, P, Attributes); 12010 } catch (e) { /* empty */ } 12011 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); 12012 if ('value' in Attributes) O[P] = Attributes.value; 12013 return O; 12014}; 12015 12016 12017/***/ }), 12018 12019/***/ 5588: 12020/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12021 12022var dP = __webpack_require__(9275); 12023var anObject = __webpack_require__(7007); 12024var getKeys = __webpack_require__(7184); 12025 12026module.exports = __webpack_require__(7057) ? Object.defineProperties : function defineProperties(O, Properties) { 12027 anObject(O); 12028 var keys = getKeys(Properties); 12029 var length = keys.length; 12030 var i = 0; 12031 var P; 12032 while (length > i) dP.f(O, P = keys[i++], Properties[P]); 12033 return O; 12034}; 12035 12036 12037/***/ }), 12038 12039/***/ 8693: 12040/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12041 12042var pIE = __webpack_require__(4682); 12043var createDesc = __webpack_require__(681); 12044var toIObject = __webpack_require__(2110); 12045var toPrimitive = __webpack_require__(1689); 12046var has = __webpack_require__(9181); 12047var IE8_DOM_DEFINE = __webpack_require__(1734); 12048var gOPD = Object.getOwnPropertyDescriptor; 12049 12050exports.f = __webpack_require__(7057) ? gOPD : function getOwnPropertyDescriptor(O, P) { 12051 O = toIObject(O); 12052 P = toPrimitive(P, true); 12053 if (IE8_DOM_DEFINE) try { 12054 return gOPD(O, P); 12055 } catch (e) { /* empty */ } 12056 if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]); 12057}; 12058 12059 12060/***/ }), 12061 12062/***/ 9327: 12063/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12064 12065// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window 12066var toIObject = __webpack_require__(2110); 12067var gOPN = (__webpack_require__(616).f); 12068var toString = {}.toString; 12069 12070var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames 12071 ? Object.getOwnPropertyNames(window) : []; 12072 12073var getWindowNames = function (it) { 12074 try { 12075 return gOPN(it); 12076 } catch (e) { 12077 return windowNames.slice(); 12078 } 12079}; 12080 12081module.exports.f = function getOwnPropertyNames(it) { 12082 return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it)); 12083}; 12084 12085 12086/***/ }), 12087 12088/***/ 616: 12089/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12090 12091// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) 12092var $keys = __webpack_require__(189); 12093var hiddenKeys = (__webpack_require__(4430).concat)('length', 'prototype'); 12094 12095exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 12096 return $keys(O, hiddenKeys); 12097}; 12098 12099 12100/***/ }), 12101 12102/***/ 4548:
vendor: 44,974 bytes, lines 12103-13564
12103/***/ (function(__unused_webpack_module, exports) { 12104 12105exports.f = Object.getOwnPropertySymbols; 12106 12107 12108/***/ }), 12109 12110/***/ 468: 12111/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12112 12113// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) 12114var has = __webpack_require__(9181); 12115var toObject = __webpack_require__(508); 12116var IE_PROTO = __webpack_require__(9335)('IE_PROTO'); 12117var ObjectProto = Object.prototype; 12118 12119module.exports = Object.getPrototypeOf || function (O) { 12120 O = toObject(O); 12121 if (has(O, IE_PROTO)) return O[IE_PROTO]; 12122 if (typeof O.constructor == 'function' && O instanceof O.constructor) { 12123 return O.constructor.prototype; 12124 } return O instanceof Object ? ObjectProto : null; 12125}; 12126 12127 12128/***/ }), 12129 12130/***/ 189: 12131/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12132 12133var has = __webpack_require__(9181); 12134var toIObject = __webpack_require__(2110); 12135var arrayIndexOf = __webpack_require__(9315)(false); 12136var IE_PROTO = __webpack_require__(9335)('IE_PROTO'); 12137 12138module.exports = function (object, names) { 12139 var O = toIObject(object); 12140 var i = 0; 12141 var result = []; 12142 var key; 12143 for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key); 12144 // Don't enum bug & hidden keys 12145 while (names.length > i) if (has(O, key = names[i++])) { 12146 ~arrayIndexOf(result, key) || result.push(key); 12147 } 12148 return result; 12149}; 12150 12151 12152/***/ }), 12153 12154/***/ 7184: 12155/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12156 12157// 19.1.2.14 / 15.2.3.14 Object.keys(O) 12158var $keys = __webpack_require__(189); 12159var enumBugKeys = __webpack_require__(4430); 12160 12161module.exports = Object.keys || function keys(O) { 12162 return $keys(O, enumBugKeys); 12163}; 12164 12165 12166/***/ }), 12167 12168/***/ 4682: 12169/***/ (function(__unused_webpack_module, exports) { 12170 12171exports.f = {}.propertyIsEnumerable; 12172 12173 12174/***/ }), 12175 12176/***/ 681: 12177/***/ (function(module) { 12178 12179module.exports = function (bitmap, value) { 12180 return { 12181 enumerable: !(bitmap & 1), 12182 configurable: !(bitmap & 2), 12183 writable: !(bitmap & 4), 12184 value: value 12185 }; 12186}; 12187 12188 12189/***/ }), 12190 12191/***/ 3415: 12192/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12193 12194var global = __webpack_require__(3816); 12195var hide = __webpack_require__(7728); 12196var has = __webpack_require__(9181); 12197var SRC = __webpack_require__(3953)('src'); 12198var $toString = __webpack_require__(18); 12199var TO_STRING = 'toString'; 12200var TPL = ('' + $toString).split(TO_STRING); 12201 12202(__webpack_require__(5645).inspectSource) = function (it) { 12203 return $toString.call(it); 12204}; 12205 12206(module.exports = function (O, key, val, safe) { 12207 var isFunction = typeof val == 'function'; 12208 if (isFunction) has(val, 'name') || hide(val, 'name', key); 12209 if (O[key] === val) return; 12210 if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); 12211 if (O === global) { 12212 O[key] = val; 12213 } else if (!safe) { 12214 delete O[key]; 12215 hide(O, key, val); 12216 } else if (O[key]) { 12217 O[key] = val; 12218 } else { 12219 hide(O, key, val); 12220 } 12221// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 12222})(Function.prototype, TO_STRING, function toString() { 12223 return typeof this == 'function' && this[SRC] || $toString.call(this); 12224}); 12225 12226 12227/***/ }), 12228 12229/***/ 7787: 12230/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12231 12232"use strict"; 12233 12234 12235var classof = __webpack_require__(1488); 12236var builtinExec = RegExp.prototype.exec; 12237 12238 // `RegExpExec` abstract operation 12239// https://tc39.github.io/ecma262/#sec-regexpexec 12240module.exports = function (R, S) { 12241 var exec = R.exec; 12242 if (typeof exec === 'function') { 12243 var result = exec.call(R, S); 12244 if (typeof result !== 'object') { 12245 throw new TypeError('RegExp exec method returned something other than an Object or null'); 12246 } 12247 return result; 12248 } 12249 if (classof(R) !== 'RegExp') { 12250 throw new TypeError('RegExp#exec called on incompatible receiver'); 12251 } 12252 return builtinExec.call(R, S); 12253}; 12254 12255 12256/***/ }), 12257 12258/***/ 1165: 12259/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12260 12261"use strict"; 12262 12263 12264var regexpFlags = __webpack_require__(3218); 12265 12266var nativeExec = RegExp.prototype.exec; 12267// This always refers to the native implementation, because the 12268// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, 12269// which loads this file before patching the method. 12270var nativeReplace = String.prototype.replace; 12271 12272var patchedExec = nativeExec; 12273 12274var LAST_INDEX = 'lastIndex'; 12275 12276var UPDATES_LAST_INDEX_WRONG = (function () { 12277 var re1 = /a/, 12278 re2 = /b*/g; 12279 nativeExec.call(re1, 'a'); 12280 nativeExec.call(re2, 'a'); 12281 return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0; 12282})(); 12283 12284// nonparticipating capturing group, copied from es5-shim's String#split patch. 12285var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; 12286 12287var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED; 12288 12289if (PATCH) { 12290 patchedExec = function exec(str) { 12291 var re = this; 12292 var lastIndex, reCopy, match, i; 12293 12294 if (NPCG_INCLUDED) { 12295 reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re)); 12296 } 12297 if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX]; 12298 12299 match = nativeExec.call(re, str); 12300 12301 if (UPDATES_LAST_INDEX_WRONG && match) { 12302 re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex; 12303 } 12304 if (NPCG_INCLUDED && match && match.length > 1) { 12305 // Fix browsers whose `exec` methods don't consistently return `undefined` 12306 // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ 12307 // eslint-disable-next-line no-loop-func 12308 nativeReplace.call(match[0], reCopy, function () { 12309 for (i = 1; i < arguments.length - 2; i++) { 12310 if (arguments[i] === undefined) match[i] = undefined; 12311 } 12312 }); 12313 } 12314 12315 return match; 12316 }; 12317} 12318 12319module.exports = patchedExec; 12320 12321 12322/***/ }), 12323 12324/***/ 7195: 12325/***/ (function(module) { 12326 12327// 7.2.9 SameValue(x, y) 12328module.exports = Object.is || function is(x, y) { 12329 // eslint-disable-next-line no-self-compare 12330 return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y; 12331}; 12332 12333 12334/***/ }), 12335 12336/***/ 2943: 12337/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12338 12339var def = (__webpack_require__(9275).f); 12340var has = __webpack_require__(9181); 12341var TAG = __webpack_require__(6314)('toStringTag'); 12342 12343module.exports = function (it, tag, stat) { 12344 if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag }); 12345}; 12346 12347 12348/***/ }), 12349 12350/***/ 9335: 12351/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12352 12353var shared = __webpack_require__(3825)('keys'); 12354var uid = __webpack_require__(3953); 12355module.exports = function (key) { 12356 return shared[key] || (shared[key] = uid(key)); 12357}; 12358 12359 12360/***/ }), 12361 12362/***/ 3825: 12363/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12364 12365var core = __webpack_require__(5645); 12366var global = __webpack_require__(3816); 12367var SHARED = '__core-js_shared__'; 12368var store = global[SHARED] || (global[SHARED] = {}); 12369 12370(module.exports = function (key, value) { 12371 return store[key] || (store[key] = value !== undefined ? value : {}); 12372})('versions', []).push({ 12373 version: core.version, 12374 mode: __webpack_require__(4461) ? 'pure' : 'global', 12375 copyright: '© 2020 Denis Pushkarev (zloirock.ru)' 12376}); 12377 12378 12379/***/ }), 12380 12381/***/ 8364: 12382/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12383 12384// 7.3.20 SpeciesConstructor(O, defaultConstructor) 12385var anObject = __webpack_require__(7007); 12386var aFunction = __webpack_require__(4963); 12387var SPECIES = __webpack_require__(6314)('species'); 12388module.exports = function (O, D) { 12389 var C = anObject(O).constructor; 12390 var S; 12391 return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); 12392}; 12393 12394 12395/***/ }), 12396 12397/***/ 7717: 12398/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12399 12400"use strict"; 12401 12402var fails = __webpack_require__(4253); 12403 12404module.exports = function (method, arg) { 12405 return !!method && fails(function () { 12406 // eslint-disable-next-line no-useless-call 12407 arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null); 12408 }); 12409}; 12410 12411 12412/***/ }), 12413 12414/***/ 4496: 12415/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12416 12417var toInteger = __webpack_require__(1467); 12418var defined = __webpack_require__(1355); 12419// true -> String#at 12420// false -> String#codePointAt 12421module.exports = function (TO_STRING) { 12422 return function (that, pos) { 12423 var s = String(defined(that)); 12424 var i = toInteger(pos); 12425 var l = s.length; 12426 var a, b; 12427 if (i < 0 || i >= l) return TO_STRING ? '' : undefined; 12428 a = s.charCodeAt(i); 12429 return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff 12430 ? TO_STRING ? s.charAt(i) : a 12431 : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; 12432 }; 12433}; 12434 12435 12436/***/ }), 12437 12438/***/ 2094: 12439/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12440 12441// helper for String#{startsWith, endsWith, includes} 12442var isRegExp = __webpack_require__(5364); 12443var defined = __webpack_require__(1355); 12444 12445module.exports = function (that, searchString, NAME) { 12446 if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!"); 12447 return String(defined(that)); 12448}; 12449 12450 12451/***/ }), 12452 12453/***/ 9395: 12454/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12455 12456var $export = __webpack_require__(2985); 12457var fails = __webpack_require__(4253); 12458var defined = __webpack_require__(1355); 12459var quot = /"/g; 12460// B.2.3.2.1 CreateHTML(string, tag, attribute, value) 12461var createHTML = function (string, tag, attribute, value) { 12462 var S = String(defined(string)); 12463 var p1 = '<' + tag; 12464 if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; 12465 return p1 + '>' + S + '</' + tag + '>'; 12466}; 12467module.exports = function (NAME, exec) { 12468 var O = {}; 12469 O[NAME] = exec(createHTML); 12470 $export($export.P + $export.F * fails(function () { 12471 var test = ''[NAME]('"'); 12472 return test !== test.toLowerCase() || test.split('"').length > 3; 12473 }), 'String', O); 12474}; 12475 12476 12477/***/ }), 12478 12479/***/ 2337: 12480/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12481 12482var toInteger = __webpack_require__(1467); 12483var max = Math.max; 12484var min = Math.min; 12485module.exports = function (index, length) { 12486 index = toInteger(index); 12487 return index < 0 ? max(index + length, 0) : min(index, length); 12488}; 12489 12490 12491/***/ }), 12492 12493/***/ 1467: 12494/***/ (function(module) { 12495 12496// 7.1.4 ToInteger 12497var ceil = Math.ceil; 12498var floor = Math.floor; 12499module.exports = function (it) { 12500 return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); 12501}; 12502 12503 12504/***/ }), 12505 12506/***/ 2110: 12507/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12508 12509// to indexed object, toObject with fallback for non-array-like ES3 strings 12510var IObject = __webpack_require__(9797); 12511var defined = __webpack_require__(1355); 12512module.exports = function (it) { 12513 return IObject(defined(it)); 12514}; 12515 12516 12517/***/ }), 12518 12519/***/ 875: 12520/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12521 12522// 7.1.15 ToLength 12523var toInteger = __webpack_require__(1467); 12524var min = Math.min; 12525module.exports = function (it) { 12526 return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 12527}; 12528 12529 12530/***/ }), 12531 12532/***/ 508: 12533/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12534 12535// 7.1.13 ToObject(argument) 12536var defined = __webpack_require__(1355); 12537module.exports = function (it) { 12538 return Object(defined(it)); 12539}; 12540 12541 12542/***/ }), 12543 12544/***/ 1689: 12545/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12546 12547// 7.1.1 ToPrimitive(input [, PreferredType]) 12548var isObject = __webpack_require__(5286); 12549// instead of the ES6 spec version, we didn't implement @@toPrimitive case 12550// and the second argument - flag - preferred type is a string 12551module.exports = function (it, S) { 12552 if (!isObject(it)) return it; 12553 var fn, val; 12554 if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; 12555 if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; 12556 if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; 12557 throw TypeError("Can't convert object to primitive value"); 12558}; 12559 12560 12561/***/ }), 12562 12563/***/ 3953: 12564/***/ (function(module) { 12565 12566var id = 0; 12567var px = Math.random(); 12568module.exports = function (key) { 12569 return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); 12570}; 12571 12572 12573/***/ }), 12574 12575/***/ 6074: 12576/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12577 12578var global = __webpack_require__(3816); 12579var core = __webpack_require__(5645); 12580var LIBRARY = __webpack_require__(4461); 12581var wksExt = __webpack_require__(8787); 12582var defineProperty = (__webpack_require__(9275).f); 12583module.exports = function (name) { 12584 var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {}); 12585 if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) }); 12586}; 12587 12588 12589/***/ }), 12590 12591/***/ 8787: 12592/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 12593 12594exports.f = __webpack_require__(6314); 12595 12596 12597/***/ }), 12598 12599/***/ 6314: 12600/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12601 12602var store = __webpack_require__(3825)('wks'); 12603var uid = __webpack_require__(3953); 12604var Symbol = (__webpack_require__(3816).Symbol); 12605var USE_SYMBOL = typeof Symbol == 'function'; 12606 12607var $exports = module.exports = function (name) { 12608 return store[name] || (store[name] = 12609 USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); 12610}; 12611 12612$exports.store = store; 12613 12614 12615/***/ }), 12616 12617/***/ 6997: 12618/***/ (function(module, __unused_webpack_exports, __webpack_require__) { 12619 12620"use strict"; 12621 12622var addToUnscopables = __webpack_require__(7722); 12623var step = __webpack_require__(5436); 12624var Iterators = __webpack_require__(7234); 12625var toIObject = __webpack_require__(2110); 12626 12627// 22.1.3.4 Array.prototype.entries() 12628// 22.1.3.13 Array.prototype.keys() 12629// 22.1.3.29 Array.prototype.values() 12630// 22.1.3.30 Array.prototype[@@iterator]() 12631module.exports = __webpack_require__(2923)(Array, 'Array', function (iterated, kind) { 12632 this._t = toIObject(iterated); // target 12633 this._i = 0; // next index 12634 this._k = kind; // kind 12635// 22.1.5.2.1 %ArrayIteratorPrototype%.next() 12636}, function () { 12637 var O = this._t; 12638 var kind = this._k; 12639 var index = this._i++; 12640 if (!O || index >= O.length) { 12641 this._t = undefined; 12642 return step(1); 12643 } 12644 if (kind == 'keys') return step(0, index); 12645 if (kind == 'values') return step(0, O[index]); 12646 return step(0, [index, O[index]]); 12647}, 'values'); 12648 12649// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) 12650Iterators.Arguments = Iterators.Array; 12651 12652addToUnscopables('keys'); 12653addToUnscopables('values'); 12654addToUnscopables('entries'); 12655 12656 12657/***/ }), 12658 12659/***/ 75: 12660/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12661 12662"use strict"; 12663 12664var $export = __webpack_require__(2985); 12665var aFunction = __webpack_require__(4963); 12666var toObject = __webpack_require__(508); 12667var fails = __webpack_require__(4253); 12668var $sort = [].sort; 12669var test = [1, 2, 3]; 12670 12671$export($export.P + $export.F * (fails(function () { 12672 // IE8- 12673 test.sort(undefined); 12674}) || !fails(function () { 12675 // V8 bug 12676 test.sort(null); 12677 // Old WebKit 12678}) || !__webpack_require__(7717)($sort)), 'Array', { 12679 // 22.1.3.25 Array.prototype.sort(comparefn) 12680 sort: function sort(comparefn) { 12681 return comparefn === undefined 12682 ? $sort.call(toObject(this)) 12683 : $sort.call(toObject(this), aFunction(comparefn)); 12684 } 12685}); 12686 12687 12688/***/ }), 12689 12690/***/ 9176: 12691/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12692 12693// 19.1.3.10 Object.is(value1, value2) 12694var $export = __webpack_require__(2985); 12695$export($export.S, 'Object', { is: __webpack_require__(7195) }); 12696 12697 12698/***/ }), 12699 12700/***/ 8269: 12701/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12702 12703"use strict"; 12704 12705var regexpExec = __webpack_require__(1165); 12706__webpack_require__(2985)({ 12707 target: 'RegExp', 12708 proto: true, 12709 forced: regexpExec !== /./.exec 12710}, { 12711 exec: regexpExec 12712}); 12713 12714 12715/***/ }), 12716 12717/***/ 6774: 12718/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12719 12720// 21.2.5.3 get RegExp.prototype.flags() 12721if (__webpack_require__(7057) && /./g.flags != 'g') (__webpack_require__(9275).f)(RegExp.prototype, 'flags', { 12722 configurable: true, 12723 get: __webpack_require__(3218) 12724}); 12725 12726 12727/***/ }), 12728 12729/***/ 1466: 12730/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12731 12732"use strict"; 12733 12734 12735var anObject = __webpack_require__(7007); 12736var toLength = __webpack_require__(875); 12737var advanceStringIndex = __webpack_require__(6793); 12738var regExpExec = __webpack_require__(7787); 12739 12740// @@match logic 12741__webpack_require__(8082)('match', 1, function (defined, MATCH, $match, maybeCallNative) { 12742 return [ 12743 // `String.prototype.match` method 12744 // https://tc39.github.io/ecma262/#sec-string.prototype.match 12745 function match(regexp) { 12746 var O = defined(this); 12747 var fn = regexp == undefined ? undefined : regexp[MATCH]; 12748 return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); 12749 }, 12750 // `RegExp.prototype[@@match]` method 12751 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match 12752 function (regexp) { 12753 var res = maybeCallNative($match, regexp, this); 12754 if (res.done) return res.value; 12755 var rx = anObject(regexp); 12756 var S = String(this); 12757 if (!rx.global) return regExpExec(rx, S); 12758 var fullUnicode = rx.unicode; 12759 rx.lastIndex = 0; 12760 var A = []; 12761 var n = 0; 12762 var result; 12763 while ((result = regExpExec(rx, S)) !== null) { 12764 var matchStr = String(result[0]); 12765 A[n] = matchStr; 12766 if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); 12767 n++; 12768 } 12769 return n === 0 ? null : A; 12770 } 12771 ]; 12772}); 12773 12774 12775/***/ }), 12776 12777/***/ 9357: 12778/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12779 12780"use strict"; 12781 12782 12783var anObject = __webpack_require__(7007); 12784var toObject = __webpack_require__(508); 12785var toLength = __webpack_require__(875); 12786var toInteger = __webpack_require__(1467); 12787var advanceStringIndex = __webpack_require__(6793); 12788var regExpExec = __webpack_require__(7787); 12789var max = Math.max; 12790var min = Math.min; 12791var floor = Math.floor; 12792var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g; 12793var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g; 12794 12795var maybeToString = function (it) { 12796 return it === undefined ? it : String(it); 12797}; 12798 12799// @@replace logic 12800__webpack_require__(8082)('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) { 12801 return [ 12802 // `String.prototype.replace` method 12803 // https://tc39.github.io/ecma262/#sec-string.prototype.replace 12804 function replace(searchValue, replaceValue) { 12805 var O = defined(this); 12806 var fn = searchValue == undefined ? undefined : searchValue[REPLACE]; 12807 return fn !== undefined 12808 ? fn.call(searchValue, O, replaceValue) 12809 : $replace.call(String(O), searchValue, replaceValue); 12810 }, 12811 // `RegExp.prototype[@@replace]` method 12812 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace 12813 function (regexp, replaceValue) { 12814 var res = maybeCallNative($replace, regexp, this, replaceValue); 12815 if (res.done) return res.value; 12816 12817 var rx = anObject(regexp); 12818 var S = String(this); 12819 var functionalReplace = typeof replaceValue === 'function'; 12820 if (!functionalReplace) replaceValue = String(replaceValue); 12821 var global = rx.global; 12822 if (global) { 12823 var fullUnicode = rx.unicode; 12824 rx.lastIndex = 0; 12825 } 12826 var results = []; 12827 while (true) { 12828 var result = regExpExec(rx, S); 12829 if (result === null) break; 12830 results.push(result); 12831 if (!global) break; 12832 var matchStr = String(result[0]); 12833 if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); 12834 } 12835 var accumulatedResult = ''; 12836 var nextSourcePosition = 0; 12837 for (var i = 0; i < results.length; i++) { 12838 result = results[i]; 12839 var matched = String(result[0]); 12840 var position = max(min(toInteger(result.index), S.length), 0); 12841 var captures = []; 12842 // NOTE: This is equivalent to 12843 // captures = result.slice(1).map(maybeToString) 12844 // but for some reason `nativeSlice.call(result, 1, result.length)` (called in 12845 // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and 12846 // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. 12847 for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); 12848 var namedCaptures = result.groups; 12849 if (functionalReplace) { 12850 var replacerArgs = [matched].concat(captures, position, S); 12851 if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); 12852 var replacement = String(replaceValue.apply(undefined, replacerArgs)); 12853 } else { 12854 replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); 12855 } 12856 if (position >= nextSourcePosition) { 12857 accumulatedResult += S.slice(nextSourcePosition, position) + replacement; 12858 nextSourcePosition = position + matched.length; 12859 } 12860 } 12861 return accumulatedResult + S.slice(nextSourcePosition); 12862 } 12863 ]; 12864 12865 // https://tc39.github.io/ecma262/#sec-getsubstitution 12866 function getSubstitution(matched, str, position, captures, namedCaptures, replacement) { 12867 var tailPos = position + matched.length; 12868 var m = captures.length; 12869 var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; 12870 if (namedCaptures !== undefined) { 12871 namedCaptures = toObject(namedCaptures); 12872 symbols = SUBSTITUTION_SYMBOLS; 12873 } 12874 return $replace.call(replacement, symbols, function (match, ch) { 12875 var capture; 12876 switch (ch.charAt(0)) { 12877 case '$': return '$'; 12878 case '&': return matched; 12879 case '`': return str.slice(0, position); 12880 case "'": return str.slice(tailPos); 12881 case '<': 12882 capture = namedCaptures[ch.slice(1, -1)]; 12883 break; 12884 default: // \d\d? 12885 var n = +ch; 12886 if (n === 0) return match; 12887 if (n > m) { 12888 var f = floor(n / 10); 12889 if (f === 0) return match; 12890 if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); 12891 return match; 12892 } 12893 capture = captures[n - 1]; 12894 } 12895 return capture === undefined ? '' : capture; 12896 }); 12897 } 12898}); 12899 12900 12901/***/ }), 12902 12903/***/ 6142: 12904/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12905 12906"use strict"; 12907 12908 12909var anObject = __webpack_require__(7007); 12910var sameValue = __webpack_require__(7195); 12911var regExpExec = __webpack_require__(7787); 12912 12913// @@search logic 12914__webpack_require__(8082)('search', 1, function (defined, SEARCH, $search, maybeCallNative) { 12915 return [ 12916 // `String.prototype.search` method 12917 // https://tc39.github.io/ecma262/#sec-string.prototype.search 12918 function search(regexp) { 12919 var O = defined(this); 12920 var fn = regexp == undefined ? undefined : regexp[SEARCH]; 12921 return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O)); 12922 }, 12923 // `RegExp.prototype[@@search]` method 12924 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search 12925 function (regexp) { 12926 var res = maybeCallNative($search, regexp, this); 12927 if (res.done) return res.value; 12928 var rx = anObject(regexp); 12929 var S = String(this); 12930 var previousLastIndex = rx.lastIndex; 12931 if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; 12932 var result = regExpExec(rx, S); 12933 if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; 12934 return result === null ? -1 : result.index; 12935 } 12936 ]; 12937}); 12938 12939 12940/***/ }), 12941 12942/***/ 1876: 12943/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 12944 12945"use strict"; 12946 12947 12948var isRegExp = __webpack_require__(5364); 12949var anObject = __webpack_require__(7007); 12950var speciesConstructor = __webpack_require__(8364); 12951var advanceStringIndex = __webpack_require__(6793); 12952var toLength = __webpack_require__(875); 12953var callRegExpExec = __webpack_require__(7787); 12954var regexpExec = __webpack_require__(1165); 12955var fails = __webpack_require__(4253); 12956var $min = Math.min; 12957var $push = [].push; 12958var $SPLIT = 'split'; 12959var LENGTH = 'length'; 12960var LAST_INDEX = 'lastIndex'; 12961var MAX_UINT32 = 0xffffffff; 12962 12963// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError 12964var SUPPORTS_Y = !fails(function () { RegExp(MAX_UINT32, 'y'); }); 12965 12966// @@split logic 12967__webpack_require__(8082)('split', 2, function (defined, SPLIT, $split, maybeCallNative) { 12968 var internalSplit; 12969 if ( 12970 'abbc'[$SPLIT](/(b)*/)[1] == 'c' || 12971 'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 || 12972 'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 || 12973 '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 || 12974 '.'[$SPLIT](/()()/)[LENGTH] > 1 || 12975 ''[$SPLIT](/.?/)[LENGTH] 12976 ) { 12977 // based on es5-shim implementation, need to rework it 12978 internalSplit = function (separator, limit) { 12979 var string = String(this); 12980 if (separator === undefined && limit === 0) return []; 12981 // If `separator` is not a regex, use native split 12982 if (!isRegExp(separator)) return $split.call(string, separator, limit); 12983 var output = []; 12984 var flags = (separator.ignoreCase ? 'i' : '') + 12985 (separator.multiline ? 'm' : '') + 12986 (separator.unicode ? 'u' : '') + 12987 (separator.sticky ? 'y' : ''); 12988 var lastLastIndex = 0; 12989 var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0; 12990 // Make `global` and avoid `lastIndex` issues by working with a copy 12991 var separatorCopy = new RegExp(separator.source, flags + 'g'); 12992 var match, lastIndex, lastLength; 12993 while (match = regexpExec.call(separatorCopy, string)) { 12994 lastIndex = separatorCopy[LAST_INDEX]; 12995 if (lastIndex > lastLastIndex) { 12996 output.push(string.slice(lastLastIndex, match.index)); 12997 if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1)); 12998 lastLength = match[0][LENGTH]; 12999 lastLastIndex = lastIndex; 13000 if (output[LENGTH] >= splitLimit) break; 13001 } 13002 if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop 13003 } 13004 if (lastLastIndex === string[LENGTH]) { 13005 if (lastLength || !separatorCopy.test('')) output.push(''); 13006 } else output.push(string.slice(lastLastIndex)); 13007 return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output; 13008 }; 13009 // Chakra, V8 13010 } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) { 13011 internalSplit = function (separator, limit) { 13012 return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit); 13013 }; 13014 } else { 13015 internalSplit = $split; 13016 } 13017 13018 return [ 13019 // `String.prototype.split` method 13020 // https://tc39.github.io/ecma262/#sec-string.prototype.split 13021 function split(separator, limit) { 13022 var O = defined(this); 13023 var splitter = separator == undefined ? undefined : separator[SPLIT]; 13024 return splitter !== undefined 13025 ? splitter.call(separator, O, limit) 13026 : internalSplit.call(String(O), separator, limit); 13027 }, 13028 // `RegExp.prototype[@@split]` method 13029 // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split 13030 // 13031 // NOTE: This cannot be properly polyfilled in engines that don't support 13032 // the 'y' flag. 13033 function (regexp, limit) { 13034 var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split); 13035 if (res.done) return res.value; 13036 13037 var rx = anObject(regexp); 13038 var S = String(this); 13039 var C = speciesConstructor(rx, RegExp); 13040 13041 var unicodeMatching = rx.unicode; 13042 var flags = (rx.ignoreCase ? 'i' : '') + 13043 (rx.multiline ? 'm' : '') + 13044 (rx.unicode ? 'u' : '') + 13045 (SUPPORTS_Y ? 'y' : 'g'); 13046 13047 // ^(? + rx + ) is needed, in combination with some S slicing, to 13048 // simulate the 'y' flag. 13049 var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); 13050 var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; 13051 if (lim === 0) return []; 13052 if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : []; 13053 var p = 0; 13054 var q = 0; 13055 var A = []; 13056 while (q < S.length) { 13057 splitter.lastIndex = SUPPORTS_Y ? q : 0; 13058 var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q)); 13059 var e; 13060 if ( 13061 z === null || 13062 (e = $min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p 13063 ) { 13064 q = advanceStringIndex(S, q, unicodeMatching); 13065 } else { 13066 A.push(S.slice(p, q)); 13067 if (A.length === lim) return A; 13068 for (var i = 1; i <= z.length - 1; i++) { 13069 A.push(z[i]); 13070 if (A.length === lim) return A; 13071 } 13072 q = p = e; 13073 } 13074 } 13075 A.push(S.slice(p)); 13076 return A; 13077 } 13078 ]; 13079}); 13080 13081 13082/***/ }), 13083 13084/***/ 6108: 13085/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13086 13087"use strict"; 13088 13089__webpack_require__(6774); 13090var anObject = __webpack_require__(7007); 13091var $flags = __webpack_require__(3218); 13092var DESCRIPTORS = __webpack_require__(7057); 13093var TO_STRING = 'toString'; 13094var $toString = /./[TO_STRING]; 13095 13096var define = function (fn) { 13097 __webpack_require__(3415)(RegExp.prototype, TO_STRING, fn, true); 13098}; 13099 13100// 21.2.5.14 RegExp.prototype.toString() 13101if (__webpack_require__(4253)(function () { return $toString.call({ source: 'a', flags: 'b' }) != '/a/b'; })) { 13102 define(function toString() { 13103 var R = anObject(this); 13104 return '/'.concat(R.source, '/', 13105 'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined); 13106 }); 13107// FF44- RegExp#toString has a wrong name 13108} else if ($toString.name != TO_STRING) { 13109 define(function toString() { 13110 return $toString.call(this); 13111 }); 13112} 13113 13114 13115/***/ }), 13116 13117/***/ 856: 13118/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13119 13120"use strict"; 13121 13122// B.2.3.2 String.prototype.anchor(name) 13123__webpack_require__(9395)('anchor', function (createHTML) { 13124 return function anchor(name) { 13125 return createHTML(this, 'a', 'name', name); 13126 }; 13127}); 13128 13129 13130/***/ }), 13131 13132/***/ 6620: 13133/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13134 13135"use strict"; 13136// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition]) 13137 13138var $export = __webpack_require__(2985); 13139var toLength = __webpack_require__(875); 13140var context = __webpack_require__(2094); 13141var ENDS_WITH = 'endsWith'; 13142var $endsWith = ''[ENDS_WITH]; 13143 13144$export($export.P + $export.F * __webpack_require__(8852)(ENDS_WITH), 'String', { 13145 endsWith: function endsWith(searchString /* , endPosition = @length */) { 13146 var that = context(this, searchString, ENDS_WITH); 13147 var endPosition = arguments.length > 1 ? arguments[1] : undefined; 13148 var len = toLength(that.length); 13149 var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len); 13150 var search = String(searchString); 13151 return $endsWith 13152 ? $endsWith.call(that, search, end) 13153 : that.slice(end - search.length, end) === search; 13154 } 13155}); 13156 13157 13158/***/ }), 13159 13160/***/ 5177: 13161/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13162 13163"use strict"; 13164 13165// B.2.3.6 String.prototype.fixed() 13166__webpack_require__(9395)('fixed', function (createHTML) { 13167 return function fixed() { 13168 return createHTML(this, 'tt', '', ''); 13169 }; 13170}); 13171 13172 13173/***/ }), 13174 13175/***/ 2850: 13176/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13177 13178"use strict"; 13179// 21.1.3.7 String.prototype.includes(searchString, position = 0) 13180 13181var $export = __webpack_require__(2985); 13182var context = __webpack_require__(2094); 13183var INCLUDES = 'includes'; 13184 13185$export($export.P + $export.F * __webpack_require__(8852)(INCLUDES), 'String', { 13186 includes: function includes(searchString /* , position = 0 */) { 13187 return !!~context(this, searchString, INCLUDES) 13188 .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined); 13189 } 13190}); 13191 13192 13193/***/ }), 13194 13195/***/ 4531: 13196/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13197 13198"use strict"; 13199 13200// B.2.3.10 String.prototype.link(url) 13201__webpack_require__(9395)('link', function (createHTML) { 13202 return function link(url) { 13203 return createHTML(this, 'a', 'href', url); 13204 }; 13205}); 13206 13207 13208/***/ }), 13209 13210/***/ 3605: 13211/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13212 13213"use strict"; 13214 13215// B.2.3.11 String.prototype.small() 13216__webpack_require__(9395)('small', function (createHTML) { 13217 return function small() { 13218 return createHTML(this, 'small', '', ''); 13219 }; 13220}); 13221 13222 13223/***/ }), 13224 13225/***/ 5767: 13226/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13227 13228"use strict"; 13229 13230// ECMAScript 6 symbols shim 13231var global = __webpack_require__(3816); 13232var has = __webpack_require__(9181); 13233var DESCRIPTORS = __webpack_require__(7057); 13234var $export = __webpack_require__(2985); 13235var redefine = __webpack_require__(3415); 13236var META = (__webpack_require__(4728).KEY); 13237var $fails = __webpack_require__(4253); 13238var shared = __webpack_require__(3825); 13239var setToStringTag = __webpack_require__(2943); 13240var uid = __webpack_require__(3953); 13241var wks = __webpack_require__(6314); 13242var wksExt = __webpack_require__(8787); 13243var wksDefine = __webpack_require__(6074); 13244var enumKeys = __webpack_require__(5541); 13245var isArray = __webpack_require__(4302); 13246var anObject = __webpack_require__(7007); 13247var isObject = __webpack_require__(5286); 13248var toObject = __webpack_require__(508); 13249var toIObject = __webpack_require__(2110); 13250var toPrimitive = __webpack_require__(1689); 13251var createDesc = __webpack_require__(681); 13252var _create = __webpack_require__(2503); 13253var gOPNExt = __webpack_require__(9327); 13254var $GOPD = __webpack_require__(8693); 13255var $GOPS = __webpack_require__(4548); 13256var $DP = __webpack_require__(9275); 13257var $keys = __webpack_require__(7184); 13258var gOPD = $GOPD.f; 13259var dP = $DP.f; 13260var gOPN = gOPNExt.f; 13261var $Symbol = global.Symbol; 13262var $JSON = global.JSON; 13263var _stringify = $JSON && $JSON.stringify; 13264var PROTOTYPE = 'prototype'; 13265var HIDDEN = wks('_hidden'); 13266var TO_PRIMITIVE = wks('toPrimitive'); 13267var isEnum = {}.propertyIsEnumerable; 13268var SymbolRegistry = shared('symbol-registry'); 13269var AllSymbols = shared('symbols'); 13270var OPSymbols = shared('op-symbols'); 13271var ObjectProto = Object[PROTOTYPE]; 13272var USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f; 13273var QObject = global.QObject; 13274// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 13275var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; 13276 13277// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 13278var setSymbolDesc = DESCRIPTORS && $fails(function () { 13279 return _create(dP({}, 'a', { 13280 get: function () { return dP(this, 'a', { value: 7 }).a; } 13281 })).a != 7; 13282}) ? function (it, key, D) { 13283 var protoDesc = gOPD(ObjectProto, key); 13284 if (protoDesc) delete ObjectProto[key]; 13285 dP(it, key, D); 13286 if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc); 13287} : dP; 13288 13289var wrap = function (tag) { 13290 var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); 13291 sym._k = tag; 13292 return sym; 13293}; 13294 13295var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) { 13296 return typeof it == 'symbol'; 13297} : function (it) { 13298 return it instanceof $Symbol; 13299}; 13300 13301var $defineProperty = function defineProperty(it, key, D) { 13302 if (it === ObjectProto) $defineProperty(OPSymbols, key, D); 13303 anObject(it); 13304 key = toPrimitive(key, true); 13305 anObject(D); 13306 if (has(AllSymbols, key)) { 13307 if (!D.enumerable) { 13308 if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {})); 13309 it[HIDDEN][key] = true; 13310 } else { 13311 if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false; 13312 D = _create(D, { enumerable: createDesc(0, false) }); 13313 } return setSymbolDesc(it, key, D); 13314 } return dP(it, key, D); 13315}; 13316var $defineProperties = function defineProperties(it, P) { 13317 anObject(it); 13318 var keys = enumKeys(P = toIObject(P)); 13319 var i = 0; 13320 var l = keys.length; 13321 var key; 13322 while (l > i) $defineProperty(it, key = keys[i++], P[key]); 13323 return it; 13324}; 13325var $create = function create(it, P) { 13326 return P === undefined ? _create(it) : $defineProperties(_create(it), P); 13327}; 13328var $propertyIsEnumerable = function propertyIsEnumerable(key) { 13329 var E = isEnum.call(this, key = toPrimitive(key, true)); 13330 if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false; 13331 return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; 13332}; 13333var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { 13334 it = toIObject(it); 13335 key = toPrimitive(key, true); 13336 if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return; 13337 var D = gOPD(it, key); 13338 if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true; 13339 return D; 13340}; 13341var $getOwnPropertyNames = function getOwnPropertyNames(it) { 13342 var names = gOPN(toIObject(it)); 13343 var result = []; 13344 var i = 0; 13345 var key; 13346 while (names.length > i) { 13347 if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key); 13348 } return result; 13349}; 13350var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { 13351 var IS_OP = it === ObjectProto; 13352 var names = gOPN(IS_OP ? OPSymbols : toIObject(it)); 13353 var result = []; 13354 var i = 0; 13355 var key; 13356 while (names.length > i) { 13357 if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]); 13358 } return result; 13359}; 13360 13361// 19.4.1.1 Symbol([description]) 13362if (!USE_NATIVE) { 13363 $Symbol = function Symbol() { 13364 if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!'); 13365 var tag = uid(arguments.length > 0 ? arguments[0] : undefined); 13366 var $set = function (value) { 13367 if (this === ObjectProto) $set.call(OPSymbols, value); 13368 if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; 13369 setSymbolDesc(this, tag, createDesc(1, value)); 13370 }; 13371 if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set }); 13372 return wrap(tag); 13373 }; 13374 redefine($Symbol[PROTOTYPE], 'toString', function toString() { 13375 return this._k; 13376 }); 13377 13378 $GOPD.f = $getOwnPropertyDescriptor; 13379 $DP.f = $defineProperty; 13380 (__webpack_require__(616).f) = gOPNExt.f = $getOwnPropertyNames; 13381 (__webpack_require__(4682).f) = $propertyIsEnumerable; 13382 $GOPS.f = $getOwnPropertySymbols; 13383 13384 if (DESCRIPTORS && !__webpack_require__(4461)) { 13385 redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); 13386 } 13387 13388 wksExt.f = function (name) { 13389 return wrap(wks(name)); 13390 }; 13391} 13392 13393$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol }); 13394 13395for (var es6Symbols = ( 13396 // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 13397 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables' 13398).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]); 13399 13400for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]); 13401 13402$export($export.S + $export.F * !USE_NATIVE, 'Symbol', { 13403 // 19.4.2.1 Symbol.for(key) 13404 'for': function (key) { 13405 return has(SymbolRegistry, key += '') 13406 ? SymbolRegistry[key] 13407 : SymbolRegistry[key] = $Symbol(key); 13408 }, 13409 // 19.4.2.5 Symbol.keyFor(sym) 13410 keyFor: function keyFor(sym) { 13411 if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!'); 13412 for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key; 13413 }, 13414 useSetter: function () { setter = true; }, 13415 useSimple: function () { setter = false; } 13416}); 13417 13418$export($export.S + $export.F * !USE_NATIVE, 'Object', { 13419 // 19.1.2.2 Object.create(O [, Properties]) 13420 create: $create, 13421 // 19.1.2.4 Object.defineProperty(O, P, Attributes) 13422 defineProperty: $defineProperty, 13423 // 19.1.2.3 Object.defineProperties(O, Properties) 13424 defineProperties: $defineProperties, 13425 // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) 13426 getOwnPropertyDescriptor: $getOwnPropertyDescriptor, 13427 // 19.1.2.7 Object.getOwnPropertyNames(O) 13428 getOwnPropertyNames: $getOwnPropertyNames, 13429 // 19.1.2.8 Object.getOwnPropertySymbols(O) 13430 getOwnPropertySymbols: $getOwnPropertySymbols 13431}); 13432 13433// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives 13434// https://bugs.chromium.org/p/v8/issues/detail?id=3443 13435var FAILS_ON_PRIMITIVES = $fails(function () { $GOPS.f(1); }); 13436 13437$export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', { 13438 getOwnPropertySymbols: function getOwnPropertySymbols(it) { 13439 return $GOPS.f(toObject(it)); 13440 } 13441}); 13442 13443// 24.3.2 JSON.stringify(value [, replacer [, space]]) 13444$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () { 13445 var S = $Symbol(); 13446 // MS Edge converts symbol values to JSON as {} 13447 // WebKit converts symbol values to JSON as null 13448 // V8 throws on boxed symbols 13449 return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}'; 13450})), 'JSON', { 13451 stringify: function stringify(it) { 13452 var args = [it]; 13453 var i = 1; 13454 var replacer, $replacer; 13455 while (arguments.length > i) args.push(arguments[i++]); 13456 $replacer = replacer = args[1]; 13457 if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined 13458 if (!isArray(replacer)) replacer = function (key, value) { 13459 if (typeof $replacer == 'function') value = $replacer.call(this, key, value); 13460 if (!isSymbol(value)) return value; 13461 }; 13462 args[1] = replacer; 13463 return _stringify.apply($JSON, args); 13464 } 13465}); 13466 13467// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) 13468$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(7728)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); 13469// 19.4.3.5 Symbol.prototype[@@toStringTag] 13470setToStringTag($Symbol, 'Symbol'); 13471// 20.2.1.9 Math[@@toStringTag] 13472setToStringTag(Math, 'Math', true); 13473// 24.3.3 JSON[@@toStringTag] 13474setToStringTag(global.JSON, 'JSON', true); 13475 13476 13477/***/ }), 13478 13479/***/ 2773: 13480/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13481 13482"use strict"; 13483 13484// https://github.com/tc39/Array.prototype.includes 13485var $export = __webpack_require__(2985); 13486var $includes = __webpack_require__(9315)(true); 13487 13488$export($export.P, 'Array', { 13489 includes: function includes(el /* , fromIndex = 0 */) { 13490 return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); 13491 } 13492}); 13493 13494__webpack_require__(7722)('includes'); 13495 13496 13497/***/ }), 13498 13499/***/ 9665: 13500/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13501 13502__webpack_require__(6074)('asyncIterator'); 13503 13504 13505/***/ }), 13506 13507/***/ 1181: 13508/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { 13509 13510var $iterators = __webpack_require__(6997); 13511var getKeys = __webpack_require__(7184); 13512var redefine = __webpack_require__(3415); 13513var global = __webpack_require__(3816); 13514var hide = __webpack_require__(7728); 13515var Iterators = __webpack_require__(7234); 13516var wks = __webpack_require__(6314); 13517var ITERATOR = wks('iterator'); 13518var TO_STRING_TAG = wks('toStringTag'); 13519var ArrayValues = Iterators.Array; 13520 13521var DOMIterables = { 13522 CSSRuleList: true, // TODO: Not spec compliant, should be false. 13523 CSSStyleDeclaration: false, 13524 CSSValueList: false, 13525 ClientRectList: false, 13526 DOMRectList: false, 13527 DOMStringList: false, 13528 DOMTokenList: true, 13529 DataTransferItemList: false, 13530 FileList: false, 13531 HTMLAllCollection: false, 13532 HTMLCollection: false, 13533 HTMLFormElement: false, 13534 HTMLSelectElement: false, 13535 MediaList: true, // TODO: Not spec compliant, should be false. 13536 MimeTypeArray: false, 13537 NamedNodeMap: false, 13538 NodeList: true, 13539 PaintRequestList: false, 13540 Plugin: false, 13541 PluginArray: false, 13542 SVGLengthList: false, 13543 SVGNumberList: false, 13544 SVGPathSegList: false, 13545 SVGPointList: false, 13546 SVGStringList: false, 13547 SVGTransformList: false, 13548 SourceBufferList: false, 13549 StyleSheetList: true, // TODO: Not spec compliant, should be false. 13550 TextTrackCueList: false, 13551 TextTrackList: false, 13552 TouchList: false 13553}; 13554 13555for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) { 13556 var NAME = collections[i]; 13557 var explicit = DOMIterables[NAME]; 13558 var Collection = global[NAME]; 13559 var proto = Collection && Collection.prototype; 13560 var key; 13561 if (proto) { 13562 if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues); 13563 if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME); 13564 Iterators[NAME] = ArrayValues;
vendor: 5,418 bytes, lines 13565-13723
13565 if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true); 13566 } 13567} 13568 13569 13570/***/ }), 13571 13572/***/ 3630: 13573/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 13574 13575"use strict"; 13576/* harmony export */ __webpack_require__.d(__webpack_exports__, { 13577/* harmony export */ Z: function() { return /* binding */ isMobile; } 13578/* harmony export */ }); 13579var appleIphone = /iPhone/i; 13580var appleIpod = /iPod/i; 13581var appleTablet = /iPad/i; 13582var appleUniversal = /\biOS-universal(?:.+)Mac\b/i; 13583var androidPhone = /\bAndroid(?:.+)Mobile\b/i; 13584var androidTablet = /Android/i; 13585var amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i; 13586var amazonTablet = /Silk/i; 13587var windowsPhone = /Windows Phone/i; 13588var windowsTablet = /\bWindows(?:.+)ARM\b/i; 13589var otherBlackBerry = /BlackBerry/i; 13590var otherBlackBerry10 = /BB10/i; 13591var otherOpera = /Opera Mini/i; 13592var otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i; 13593var otherFirefox = /Mobile(?:.+)Firefox\b/i; 13594var isAppleTabletOnIos13 = function (navigator) { 13595 return (typeof navigator !== 'undefined' && 13596 navigator.platform === 'MacIntel' && 13597 typeof navigator.maxTouchPoints === 'number' && 13598 navigator.maxTouchPoints > 1 && 13599 typeof MSStream === 'undefined'); 13600}; 13601function createMatch(userAgent) { 13602 return function (regex) { return regex.test(userAgent); }; 13603} 13604function isMobile(param) { 13605 var nav = { 13606 userAgent: '', 13607 platform: '', 13608 maxTouchPoints: 0 13609 }; 13610 if (!param && typeof navigator !== 'undefined') { 13611 nav = { 13612 userAgent: navigator.userAgent, 13613 platform: navigator.platform, 13614 maxTouchPoints: navigator.maxTouchPoints || 0 13615 }; 13616 } 13617 else if (typeof param === 'string') { 13618 nav.userAgent = param; 13619 } 13620 else if (param && param.userAgent) { 13621 nav = { 13622 userAgent: param.userAgent, 13623 platform: param.platform, 13624 maxTouchPoints: param.maxTouchPoints || 0 13625 }; 13626 } 13627 var userAgent = nav.userAgent; 13628 var tmp = userAgent.split('[FBAN'); 13629 if (typeof tmp[1] !== 'undefined') { 13630 userAgent = tmp[0]; 13631 } 13632 tmp = userAgent.split('Twitter'); 13633 if (typeof tmp[1] !== 'undefined') { 13634 userAgent = tmp[0]; 13635 } 13636 var match = createMatch(userAgent); 13637 var result = { 13638 apple: { 13639 phone: match(appleIphone) && !match(windowsPhone), 13640 ipod: match(appleIpod), 13641 tablet: !match(appleIphone) && 13642 (match(appleTablet) || isAppleTabletOnIos13(nav)) && 13643 !match(windowsPhone), 13644 universal: match(appleUniversal), 13645 device: (match(appleIphone) || 13646 match(appleIpod) || 13647 match(appleTablet) || 13648 match(appleUniversal) || 13649 isAppleTabletOnIos13(nav)) && 13650 !match(windowsPhone) 13651 }, 13652 amazon: { 13653 phone: match(amazonPhone), 13654 tablet: !match(amazonPhone) && match(amazonTablet), 13655 device: match(amazonPhone) || match(amazonTablet) 13656 }, 13657 android: { 13658 phone: (!match(windowsPhone) && match(amazonPhone)) || 13659 (!match(windowsPhone) && match(androidPhone)), 13660 tablet: !match(windowsPhone) && 13661 !match(amazonPhone) && 13662 !match(androidPhone) && 13663 (match(amazonTablet) || match(androidTablet)), 13664 device: (!match(windowsPhone) && 13665 (match(amazonPhone) || 13666 match(amazonTablet) || 13667 match(androidPhone) || 13668 match(androidTablet))) || 13669 match(/\bokhttp\b/i) 13670 }, 13671 windows: { 13672 phone: match(windowsPhone), 13673 tablet: match(windowsTablet), 13674 device: match(windowsPhone) || match(windowsTablet) 13675 }, 13676 other: { 13677 blackberry: match(otherBlackBerry), 13678 blackberry10: match(otherBlackBerry10), 13679 opera: match(otherOpera), 13680 firefox: match(otherFirefox), 13681 chrome: match(otherChrome), 13682 device: match(otherBlackBerry) || 13683 match(otherBlackBerry10) || 13684 match(otherOpera) || 13685 match(otherFirefox) || 13686 match(otherChrome) 13687 }, 13688 any: false, 13689 phone: false, 13690 tablet: false 13691 }; 13692 result.any = 13693 result.apple.device || 13694 result.android.device || 13695 result.windows.device || 13696 result.other.device; 13697 result.phone = 13698 result.apple.phone || result.android.phone || result.windows.phone; 13699 result.tablet = 13700 result.apple.tablet || result.android.tablet || result.windows.tablet; 13701 return result; 13702} 13703//# sourceMappingURL=isMobile.js.map 13704 13705/***/ }), 13706 13707/***/ 6808: 13708/***/ (function(module, exports, __webpack_require__) { 13709 13710var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 13711 * JavaScript Cookie v2.2.1 13712 * https://github.com/js-cookie/js-cookie 13713 * 13714 * Copyright 2006, 2015 Klaus Hartl & Fagner Brack 13715 * Released under the MIT license 13716 */ 13717;(function (factory) { 13718 var registeredInModuleLoader; 13719 if (true) { 13720 !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), 13721 __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? 13722 (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : 13723 __WEBPACK_AMD_DEFINE_FACTORY__),
vendor: 3,952 bytes, lines 13724-13890
13724 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 13725 registeredInModuleLoader = true; 13726 } 13727 if (true) { 13728 module.exports = factory(); 13729 registeredInModuleLoader = true; 13730 } 13731 if (!registeredInModuleLoader) { 13732 var OldCookies = window.Cookies; 13733 var api = window.Cookies = factory(); 13734 api.noConflict = function () { 13735 window.Cookies = OldCookies; 13736 return api; 13737 }; 13738 } 13739}(function () { 13740 function extend () { 13741 var i = 0; 13742 var result = {}; 13743 for (; i < arguments.length; i++) { 13744 var attributes = arguments[ i ]; 13745 for (var key in attributes) { 13746 result[key] = attributes[key]; 13747 } 13748 } 13749 return result; 13750 } 13751 13752 function decode (s) { 13753 return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent); 13754 } 13755 13756 function init (converter) { 13757 function api() {} 13758 13759 function set (key, value, attributes) { 13760 if (typeof document === 'undefined') { 13761 return; 13762 } 13763 13764 attributes = extend({ 13765 path: '/' 13766 }, api.defaults, attributes); 13767 13768 if (typeof attributes.expires === 'number') { 13769 attributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5); 13770 } 13771 13772 // We're using "expires" because "max-age" is not supported by IE 13773 attributes.expires = attributes.expires ? attributes.expires.toUTCString() : ''; 13774 13775 try { 13776 var result = JSON.stringify(value); 13777 if (/^[\{\[]/.test(result)) { 13778 value = result; 13779 } 13780 } catch (e) {} 13781 13782 value = converter.write ? 13783 converter.write(value, key) : 13784 encodeURIComponent(String(value)) 13785 .replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent); 13786 13787 key = encodeURIComponent(String(key)) 13788 .replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent) 13789 .replace(/[\(\)]/g, escape); 13790 13791 var stringifiedAttributes = ''; 13792 for (var attributeName in attributes) { 13793 if (!attributes[attributeName]) { 13794 continue; 13795 } 13796 stringifiedAttributes += '; ' + attributeName; 13797 if (attributes[attributeName] === true) { 13798 continue; 13799 } 13800 13801 // Considers RFC 6265 section 5.2: 13802 // ... 13803 // 3. If the remaining unparsed-attributes contains a %x3B (";") 13804 // character: 13805 // Consume the characters of the unparsed-attributes up to, 13806 // not including, the first %x3B (";") character. 13807 // ... 13808 stringifiedAttributes += '=' + attributes[attributeName].split(';')[0]; 13809 } 13810 13811 return (document.cookie = key + '=' + value + stringifiedAttributes); 13812 } 13813 13814 function get (key, json) { 13815 if (typeof document === 'undefined') { 13816 return; 13817 } 13818 13819 var jar = {}; 13820 // To prevent the for loop in the first place assign an empty array 13821 // in case there are no cookies at all. 13822 var cookies = document.cookie ? document.cookie.split('; ') : []; 13823 var i = 0; 13824 13825 for (; i < cookies.length; i++) { 13826 var parts = cookies[i].split('='); 13827 var cookie = parts.slice(1).join('='); 13828 13829 if (!json && cookie.charAt(0) === '"') { 13830 cookie = cookie.slice(1, -1); 13831 } 13832 13833 try { 13834 var name = decode(parts[0]); 13835 cookie = (converter.read || converter)(cookie, name) || 13836 decode(cookie); 13837 13838 if (json) { 13839 try { 13840 cookie = JSON.parse(cookie); 13841 } catch (e) {} 13842 } 13843 13844 jar[name] = cookie; 13845 13846 if (key === name) { 13847 break; 13848 } 13849 } catch (e) {} 13850 } 13851 13852 return key ? jar[key] : jar; 13853 } 13854 13855 api.set = set; 13856 api.get = function (key) { 13857 return get(key, false /* read as raw */); 13858 }; 13859 api.getJSON = function (key) { 13860 return get(key, true /* read as json */); 13861 }; 13862 api.remove = function (key, attributes) { 13863 set(key, '', extend(attributes, { 13864 expires: -1 13865 })); 13866 }; 13867 13868 api.defaults = {}; 13869 13870 api.withConverter = init; 13871 13872 return api; 13873 } 13874 13875 return init(function () {}); 13876})); 13877 13878 13879/***/ }), 13880 13881/***/ 4104: 13882/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 13883 13884"use strict"; 13885/* unused harmony exports Url, Http, Resource */ 13886/*! 13887 * vue-resource v1.5.3 13888 * https://github.com/pagekit/vue-resource 13889 * Released under the MIT License. 13890 */
vendor: 22,896 bytes, lines 13890-14889
13890 13891 13892/** 13893 * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis) 13894 */ 13895var RESOLVED = 0; 13896var REJECTED = 1; 13897var PENDING = 2; 13898function Promise$1(executor) { 13899 this.state = PENDING; 13900 this.value = undefined; 13901 this.deferred = []; 13902 var promise = this; 13903 13904 try { 13905 executor(function (x) { 13906 promise.resolve(x); 13907 }, function (r) { 13908 promise.reject(r); 13909 }); 13910 } catch (e) { 13911 promise.reject(e); 13912 } 13913} 13914 13915Promise$1.reject = function (r) { 13916 return new Promise$1(function (resolve, reject) { 13917 reject(r); 13918 }); 13919}; 13920 13921Promise$1.resolve = function (x) { 13922 return new Promise$1(function (resolve, reject) { 13923 resolve(x); 13924 }); 13925}; 13926 13927Promise$1.all = function all(iterable) { 13928 return new Promise$1(function (resolve, reject) { 13929 var count = 0, 13930 result = []; 13931 13932 if (iterable.length === 0) { 13933 resolve(result); 13934 } 13935 13936 function resolver(i) { 13937 return function (x) { 13938 result[i] = x; 13939 count += 1; 13940 13941 if (count === iterable.length) { 13942 resolve(result); 13943 } 13944 }; 13945 } 13946 13947 for (var i = 0; i < iterable.length; i += 1) { 13948 Promise$1.resolve(iterable[i]).then(resolver(i), reject); 13949 } 13950 }); 13951}; 13952 13953Promise$1.race = function race(iterable) { 13954 return new Promise$1(function (resolve, reject) { 13955 for (var i = 0; i < iterable.length; i += 1) { 13956 Promise$1.resolve(iterable[i]).then(resolve, reject); 13957 } 13958 }); 13959}; 13960 13961var p = Promise$1.prototype; 13962 13963p.resolve = function resolve(x) { 13964 var promise = this; 13965 13966 if (promise.state === PENDING) { 13967 if (x === promise) { 13968 throw new TypeError('Promise settled with itself.'); 13969 } 13970 13971 var called = false; 13972 13973 try { 13974 var then = x && x['then']; 13975 13976 if (x !== null && typeof x === 'object' && typeof then === 'function') { 13977 then.call(x, function (x) { 13978 if (!called) { 13979 promise.resolve(x); 13980 } 13981 13982 called = true; 13983 }, function (r) { 13984 if (!called) { 13985 promise.reject(r); 13986 } 13987 13988 called = true; 13989 }); 13990 return; 13991 } 13992 } catch (e) { 13993 if (!called) { 13994 promise.reject(e); 13995 } 13996 13997 return; 13998 } 13999 14000 promise.state = RESOLVED; 14001 promise.value = x; 14002 promise.notify(); 14003 } 14004}; 14005 14006p.reject = function reject(reason) { 14007 var promise = this; 14008 14009 if (promise.state === PENDING) { 14010 if (reason === promise) { 14011 throw new TypeError('Promise settled with itself.'); 14012 } 14013 14014 promise.state = REJECTED; 14015 promise.value = reason; 14016 promise.notify(); 14017 } 14018}; 14019 14020p.notify = function notify() { 14021 var promise = this; 14022 nextTick(function () { 14023 if (promise.state !== PENDING) { 14024 while (promise.deferred.length) { 14025 var deferred = promise.deferred.shift(), 14026 onResolved = deferred[0], 14027 onRejected = deferred[1], 14028 resolve = deferred[2], 14029 reject = deferred[3]; 14030 14031 try { 14032 if (promise.state === RESOLVED) { 14033 if (typeof onResolved === 'function') { 14034 resolve(onResolved.call(undefined, promise.value)); 14035 } else { 14036 resolve(promise.value); 14037 } 14038 } else if (promise.state === REJECTED) { 14039 if (typeof onRejected === 'function') { 14040 resolve(onRejected.call(undefined, promise.value)); 14041 } else { 14042 reject(promise.value); 14043 } 14044 } 14045 } catch (e) { 14046 reject(e); 14047 } 14048 } 14049 } 14050 }); 14051}; 14052 14053p.then = function then(onResolved, onRejected) { 14054 var promise = this; 14055 return new Promise$1(function (resolve, reject) { 14056 promise.deferred.push([onResolved, onRejected, resolve, reject]); 14057 promise.notify(); 14058 }); 14059}; 14060 14061p["catch"] = function (onRejected) { 14062 return this.then(undefined, onRejected); 14063}; 14064 14065/** 14066 * Promise adapter. 14067 */ 14068 14069if (typeof Promise === 'undefined') { 14070 window.Promise = Promise$1; 14071} 14072 14073function PromiseObj(executor, context) { 14074 if (executor instanceof Promise) { 14075 this.promise = executor; 14076 } else { 14077 this.promise = new Promise(executor.bind(context)); 14078 } 14079 14080 this.context = context; 14081} 14082 14083PromiseObj.all = function (iterable, context) { 14084 return new PromiseObj(Promise.all(iterable), context); 14085}; 14086 14087PromiseObj.resolve = function (value, context) { 14088 return new PromiseObj(Promise.resolve(value), context); 14089}; 14090 14091PromiseObj.reject = function (reason, context) { 14092 return new PromiseObj(Promise.reject(reason), context); 14093}; 14094 14095PromiseObj.race = function (iterable, context) { 14096 return new PromiseObj(Promise.race(iterable), context); 14097}; 14098 14099var p$1 = PromiseObj.prototype; 14100 14101p$1.bind = function (context) { 14102 this.context = context; 14103 return this; 14104}; 14105 14106p$1.then = function (fulfilled, rejected) { 14107 if (fulfilled && fulfilled.bind && this.context) { 14108 fulfilled = fulfilled.bind(this.context); 14109 } 14110 14111 if (rejected && rejected.bind && this.context) { 14112 rejected = rejected.bind(this.context); 14113 } 14114 14115 return new PromiseObj(this.promise.then(fulfilled, rejected), this.context); 14116}; 14117 14118p$1["catch"] = function (rejected) { 14119 if (rejected && rejected.bind && this.context) { 14120 rejected = rejected.bind(this.context); 14121 } 14122 14123 return new PromiseObj(this.promise["catch"](rejected), this.context); 14124}; 14125 14126p$1["finally"] = function (callback) { 14127 return this.then(function (value) { 14128 callback.call(this); 14129 return value; 14130 }, function (reason) { 14131 callback.call(this); 14132 return Promise.reject(reason); 14133 }); 14134}; 14135 14136/** 14137 * Utility functions. 14138 */ 14139var _ref = {}, 14140 hasOwnProperty = _ref.hasOwnProperty, 14141 slice = [].slice, 14142 debug = false, 14143 ntick; 14144var inBrowser = typeof window !== 'undefined'; 14145function Util (_ref2) { 14146 var config = _ref2.config, 14147 nextTick = _ref2.nextTick; 14148 ntick = nextTick; 14149 debug = config.debug || !config.silent; 14150} 14151function warn(msg) { 14152 if (typeof console !== 'undefined' && debug) { 14153 console.warn('[VueResource warn]: ' + msg); 14154 } 14155} 14156function error(msg) { 14157 if (typeof console !== 'undefined') { 14158 console.error(msg); 14159 } 14160} 14161function nextTick(cb, ctx) { 14162 return ntick(cb, ctx); 14163} 14164function trim(str) { 14165 return str ? str.replace(/^\s*|\s*$/g, '') : ''; 14166} 14167function trimEnd(str, chars) { 14168 if (str && chars === undefined) { 14169 return str.replace(/\s+$/, ''); 14170 } 14171 14172 if (!str || !chars) { 14173 return str; 14174 } 14175 14176 return str.replace(new RegExp("[" + chars + "]+$"), ''); 14177} 14178function toLower(str) { 14179 return str ? str.toLowerCase() : ''; 14180} 14181function toUpper(str) { 14182 return str ? str.toUpperCase() : ''; 14183} 14184var isArray = Array.isArray; 14185function isString(val) { 14186 return typeof val === 'string'; 14187} 14188function isFunction(val) { 14189 return typeof val === 'function'; 14190} 14191function isObject(obj) { 14192 return obj !== null && typeof obj === 'object'; 14193} 14194function isPlainObject(obj) { 14195 return isObject(obj) && Object.getPrototypeOf(obj) == Object.prototype; 14196} 14197function isBlob(obj) { 14198 return typeof Blob !== 'undefined' && obj instanceof Blob; 14199} 14200function isFormData(obj) { 14201 return typeof FormData !== 'undefined' && obj instanceof FormData; 14202} 14203function when(value, fulfilled, rejected) { 14204 var promise = PromiseObj.resolve(value); 14205 14206 if (arguments.length < 2) { 14207 return promise; 14208 } 14209 14210 return promise.then(fulfilled, rejected); 14211} 14212function options(fn, obj, opts) { 14213 opts = opts || {}; 14214 14215 if (isFunction(opts)) { 14216 opts = opts.call(obj); 14217 } 14218 14219 return merge(fn.bind({ 14220 $vm: obj, 14221 $options: opts 14222 }), fn, { 14223 $options: opts 14224 }); 14225} 14226function each(obj, iterator) { 14227 var i, key; 14228 14229 if (isArray(obj)) { 14230 for (i = 0; i < obj.length; i++) { 14231 iterator.call(obj[i], obj[i], i); 14232 } 14233 } else if (isObject(obj)) { 14234 for (key in obj) { 14235 if (hasOwnProperty.call(obj, key)) { 14236 iterator.call(obj[key], obj[key], key); 14237 } 14238 } 14239 } 14240 14241 return obj; 14242} 14243var assign = Object.assign || _assign; 14244function merge(target) { 14245 var args = slice.call(arguments, 1); 14246 args.forEach(function (source) { 14247 _merge(target, source, true); 14248 }); 14249 return target; 14250} 14251function defaults(target) { 14252 var args = slice.call(arguments, 1); 14253 args.forEach(function (source) { 14254 for (var key in source) { 14255 if (target[key] === undefined) { 14256 target[key] = source[key]; 14257 } 14258 } 14259 }); 14260 return target; 14261} 14262 14263function _assign(target) { 14264 var args = slice.call(arguments, 1); 14265 args.forEach(function (source) { 14266 _merge(target, source); 14267 }); 14268 return target; 14269} 14270 14271function _merge(target, source, deep) { 14272 for (var key in source) { 14273 if (deep && (isPlainObject(source[key]) || isArray(source[key]))) { 14274 if (isPlainObject(source[key]) && !isPlainObject(target[key])) { 14275 target[key] = {}; 14276 } 14277 14278 if (isArray(source[key]) && !isArray(target[key])) { 14279 target[key] = []; 14280 } 14281 14282 _merge(target[key], source[key], deep); 14283 } else if (source[key] !== undefined) { 14284 target[key] = source[key]; 14285 } 14286 } 14287} 14288 14289/** 14290 * Root Prefix Transform. 14291 */ 14292function root (options$$1, next) { 14293 var url = next(options$$1); 14294 14295 if (isString(options$$1.root) && !/^(https?:)?\//.test(url)) { 14296 url = trimEnd(options$$1.root, '/') + '/' + url; 14297 } 14298 14299 return url; 14300} 14301 14302/** 14303 * Query Parameter Transform. 14304 */ 14305function query (options$$1, next) { 14306 var urlParams = Object.keys(Url.options.params), 14307 query = {}, 14308 url = next(options$$1); 14309 each(options$$1.params, function (value, key) { 14310 if (urlParams.indexOf(key) === -1) { 14311 query[key] = value; 14312 } 14313 }); 14314 query = Url.params(query); 14315 14316 if (query) { 14317 url += (url.indexOf('?') == -1 ? '?' : '&') + query; 14318 } 14319 14320 return url; 14321} 14322 14323/** 14324 * URL Template v2.0.6 (https://github.com/bramstein/url-template) 14325 */ 14326function expand(url, params, variables) { 14327 var tmpl = parse(url), 14328 expanded = tmpl.expand(params); 14329 14330 if (variables) { 14331 variables.push.apply(variables, tmpl.vars); 14332 } 14333 14334 return expanded; 14335} 14336function parse(template) { 14337 var operators = ['+', '#', '.', '/', ';', '?', '&'], 14338 variables = []; 14339 return { 14340 vars: variables, 14341 expand: function expand(context) { 14342 return template.replace(/\{([^{}]+)\}|([^{}]+)/g, function (_, expression, literal) { 14343 if (expression) { 14344 var operator = null, 14345 values = []; 14346 14347 if (operators.indexOf(expression.charAt(0)) !== -1) { 14348 operator = expression.charAt(0); 14349 expression = expression.substr(1); 14350 } 14351 14352 expression.split(/,/g).forEach(function (variable) { 14353 var tmp = /([^:*]*)(?::(\d+)|(\*))?/.exec(variable); 14354 values.push.apply(values, getValues(context, operator, tmp[1], tmp[2] || tmp[3])); 14355 variables.push(tmp[1]); 14356 }); 14357 14358 if (operator && operator !== '+') { 14359 var separator = ','; 14360 14361 if (operator === '?') { 14362 separator = '&'; 14363 } else if (operator !== '#') { 14364 separator = operator; 14365 } 14366 14367 return (values.length !== 0 ? operator : '') + values.join(separator); 14368 } else { 14369 return values.join(','); 14370 } 14371 } else { 14372 return encodeReserved(literal); 14373 } 14374 }); 14375 } 14376 }; 14377} 14378 14379function getValues(context, operator, key, modifier) { 14380 var value = context[key], 14381 result = []; 14382 14383 if (isDefined(value) && value !== '') { 14384 if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') { 14385 value = value.toString(); 14386 14387 if (modifier && modifier !== '*') { 14388 value = value.substring(0, parseInt(modifier, 10)); 14389 } 14390 14391 result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null)); 14392 } else { 14393 if (modifier === '*') { 14394 if (Array.isArray(value)) { 14395 value.filter(isDefined).forEach(function (value) { 14396 result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : null)); 14397 }); 14398 } else { 14399 Object.keys(value).forEach(function (k) { 14400 if (isDefined(value[k])) { 14401 result.push(encodeValue(operator, value[k], k)); 14402 } 14403 }); 14404 } 14405 } else { 14406 var tmp = []; 14407 14408 if (Array.isArray(value)) { 14409 value.filter(isDefined).forEach(function (value) { 14410 tmp.push(encodeValue(operator, value)); 14411 }); 14412 } else { 14413 Object.keys(value).forEach(function (k) { 14414 if (isDefined(value[k])) { 14415 tmp.push(encodeURIComponent(k)); 14416 tmp.push(encodeValue(operator, value[k].toString())); 14417 } 14418 }); 14419 } 14420 14421 if (isKeyOperator(operator)) { 14422 result.push(encodeURIComponent(key) + '=' + tmp.join(',')); 14423 } else if (tmp.length !== 0) { 14424 result.push(tmp.join(',')); 14425 } 14426 } 14427 } 14428 } else { 14429 if (operator === ';') { 14430 result.push(encodeURIComponent(key)); 14431 } else if (value === '' && (operator === '&' || operator === '?')) { 14432 result.push(encodeURIComponent(key) + '='); 14433 } else if (value === '') { 14434 result.push(''); 14435 } 14436 } 14437 14438 return result; 14439} 14440 14441function isDefined(value) { 14442 return value !== undefined && value !== null; 14443} 14444 14445function isKeyOperator(operator) { 14446 return operator === ';' || operator === '&' || operator === '?'; 14447} 14448 14449function encodeValue(operator, value, key) { 14450 value = operator === '+' || operator === '#' ? encodeReserved(value) : encodeURIComponent(value); 14451 14452 if (key) { 14453 return encodeURIComponent(key) + '=' + value; 14454 } else { 14455 return value; 14456 } 14457} 14458 14459function encodeReserved(str) { 14460 return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) { 14461 if (!/%[0-9A-Fa-f]/.test(part)) { 14462 part = encodeURI(part); 14463 } 14464 14465 return part; 14466 }).join(''); 14467} 14468 14469/** 14470 * URL Template (RFC 6570) Transform. 14471 */ 14472function template (options) { 14473 var variables = [], 14474 url = expand(options.url, options.params, variables); 14475 variables.forEach(function (key) { 14476 delete options.params[key]; 14477 }); 14478 return url; 14479} 14480 14481/** 14482 * Service for URL templating. 14483 */ 14484function Url(url, params) { 14485 var self = this || {}, 14486 options$$1 = url, 14487 transform; 14488 14489 if (isString(url)) { 14490 options$$1 = { 14491 url: url, 14492 params: params 14493 }; 14494 } 14495 14496 options$$1 = merge({}, Url.options, self.$options, options$$1); 14497 Url.transforms.forEach(function (handler) { 14498 if (isString(handler)) { 14499 handler = Url.transform[handler]; 14500 } 14501 14502 if (isFunction(handler)) { 14503 transform = factory(handler, transform, self.$vm); 14504 } 14505 }); 14506 return transform(options$$1); 14507} 14508/** 14509 * Url options. 14510 */ 14511 14512Url.options = { 14513 url: '', 14514 root: null, 14515 params: {} 14516}; 14517/** 14518 * Url transforms. 14519 */ 14520 14521Url.transform = { 14522 template: template, 14523 query: query, 14524 root: root 14525}; 14526Url.transforms = ['template', 'query', 'root']; 14527/** 14528 * Encodes a Url parameter string. 14529 * 14530 * @param {Object} obj 14531 */ 14532 14533Url.params = function (obj) { 14534 var params = [], 14535 escape = encodeURIComponent; 14536 14537 params.add = function (key, value) { 14538 if (isFunction(value)) { 14539 value = value(); 14540 } 14541 14542 if (value === null) { 14543 value = ''; 14544 } 14545 14546 this.push(escape(key) + '=' + escape(value)); 14547 }; 14548 14549 serialize(params, obj); 14550 return params.join('&').replace(/%20/g, '+'); 14551}; 14552/** 14553 * Parse a URL and return its components. 14554 * 14555 * @param {String} url 14556 */ 14557 14558 14559Url.parse = function (url) { 14560 var el = document.createElement('a'); 14561 14562 if (document.documentMode) { 14563 el.href = url; 14564 url = el.href; 14565 } 14566 14567 el.href = url; 14568 return { 14569 href: el.href, 14570 protocol: el.protocol ? el.protocol.replace(/:$/, '') : '', 14571 port: el.port, 14572 host: el.host, 14573 hostname: el.hostname, 14574 pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname, 14575 search: el.search ? el.search.replace(/^\?/, '') : '', 14576 hash: el.hash ? el.hash.replace(/^#/, '') : '' 14577 }; 14578}; 14579 14580function factory(handler, next, vm) { 14581 return function (options$$1) { 14582 return handler.call(vm, options$$1, next); 14583 }; 14584} 14585 14586function serialize(params, obj, scope) { 14587 var array = isArray(obj), 14588 plain = isPlainObject(obj), 14589 hash; 14590 each(obj, function (value, key) { 14591 hash = isObject(value) || isArray(value); 14592 14593 if (scope) { 14594 key = scope + '[' + (plain || hash ? key : '') + ']'; 14595 } 14596 14597 if (!scope && array) { 14598 params.add(value.name, value.value); 14599 } else if (hash) { 14600 serialize(params, value, key); 14601 } else { 14602 params.add(key, value); 14603 } 14604 }); 14605} 14606 14607/** 14608 * XDomain client (Internet Explorer). 14609 */ 14610function xdrClient (request) { 14611 return new PromiseObj(function (resolve) { 14612 var xdr = new XDomainRequest(), 14613 handler = function handler(_ref) { 14614 var type = _ref.type; 14615 var status = 0; 14616 14617 if (type === 'load') { 14618 status = 200; 14619 } else if (type === 'error') { 14620 status = 500; 14621 } 14622 14623 resolve(request.respondWith(xdr.responseText, { 14624 status: status 14625 })); 14626 }; 14627 14628 request.abort = function () { 14629 return xdr.abort(); 14630 }; 14631 14632 xdr.open(request.method, request.getUrl()); 14633 14634 if (request.timeout) { 14635 xdr.timeout = request.timeout; 14636 } 14637 14638 xdr.onload = handler; 14639 xdr.onabort = handler; 14640 xdr.onerror = handler; 14641 xdr.ontimeout = handler; 14642 14643 xdr.onprogress = function () {}; 14644 14645 xdr.send(request.getBody()); 14646 }); 14647} 14648 14649/** 14650 * CORS Interceptor. 14651 */ 14652var SUPPORTS_CORS = inBrowser && 'withCredentials' in new XMLHttpRequest(); 14653function cors (request) { 14654 if (inBrowser) { 14655 var orgUrl = Url.parse(location.href); 14656 var reqUrl = Url.parse(request.getUrl()); 14657 14658 if (reqUrl.protocol !== orgUrl.protocol || reqUrl.host !== orgUrl.host) { 14659 request.crossOrigin = true; 14660 request.emulateHTTP = false; 14661 14662 if (!SUPPORTS_CORS) { 14663 request.client = xdrClient; 14664 } 14665 } 14666 } 14667} 14668 14669/** 14670 * Form data Interceptor. 14671 */ 14672function form (request) { 14673 if (isFormData(request.body)) { 14674 request.headers["delete"]('Content-Type'); 14675 } else if (isObject(request.body) && request.emulateJSON) { 14676 request.body = Url.params(request.body); 14677 request.headers.set('Content-Type', 'application/x-www-form-urlencoded'); 14678 } 14679} 14680 14681/** 14682 * JSON Interceptor. 14683 */ 14684function json (request) { 14685 var type = request.headers.get('Content-Type') || ''; 14686 14687 if (isObject(request.body) && type.indexOf('application/json') === 0) { 14688 request.body = JSON.stringify(request.body); 14689 } 14690 14691 return function (response) { 14692 return response.bodyText ? when(response.text(), function (text) { 14693 var type = response.headers.get('Content-Type') || ''; 14694 14695 if (type.indexOf('application/json') === 0 || isJson(text)) { 14696 try { 14697 response.body = JSON.parse(text); 14698 } catch (e) { 14699 response.body = null; 14700 } 14701 } else { 14702 response.body = text; 14703 } 14704 14705 return response; 14706 }) : response; 14707 }; 14708} 14709 14710function isJson(str) { 14711 var start = str.match(/^\s*(\[|\{)/); 14712 var end = { 14713 '[': /]\s*$/, 14714 '{': /}\s*$/ 14715 }; 14716 return start && end[start[1]].test(str); 14717} 14718 14719/** 14720 * JSONP client (Browser). 14721 */ 14722function jsonpClient (request) { 14723 return new PromiseObj(function (resolve) { 14724 var name = request.jsonp || 'callback', 14725 callback = request.jsonpCallback || '_jsonp' + Math.random().toString(36).substr(2), 14726 body = null, 14727 handler, 14728 script; 14729 14730 handler = function handler(_ref) { 14731 var type = _ref.type; 14732 var status = 0; 14733 14734 if (type === 'load' && body !== null) { 14735 status = 200; 14736 } else if (type === 'error') { 14737 status = 500; 14738 } 14739 14740 if (status && window[callback]) { 14741 delete window[callback]; 14742 document.body.removeChild(script); 14743 } 14744 14745 resolve(request.respondWith(body, { 14746 status: status 14747 })); 14748 }; 14749 14750 window[callback] = function (result) { 14751 body = JSON.stringify(result); 14752 }; 14753 14754 request.abort = function () { 14755 handler({ 14756 type: 'abort' 14757 }); 14758 }; 14759 14760 request.params[name] = callback; 14761 14762 if (request.timeout) { 14763 setTimeout(request.abort, request.timeout); 14764 } 14765 14766 script = document.createElement('script'); 14767 script.src = request.getUrl(); 14768 script.type = 'text/javascript'; 14769 script.async = true; 14770 script.onload = handler; 14771 script.onerror = handler; 14772 document.body.appendChild(script); 14773 }); 14774} 14775 14776/** 14777 * JSONP Interceptor. 14778 */ 14779function jsonp (request) { 14780 if (request.method == 'JSONP') { 14781 request.client = jsonpClient; 14782 } 14783} 14784 14785/** 14786 * Before Interceptor. 14787 */ 14788function before (request) { 14789 if (isFunction(request.before)) { 14790 request.before.call(this, request); 14791 } 14792} 14793 14794/** 14795 * HTTP method override Interceptor. 14796 */ 14797function method (request) { 14798 if (request.emulateHTTP && /^(PUT|PATCH|DELETE)$/i.test(request.method)) { 14799 request.headers.set('X-HTTP-Method-Override', request.method); 14800 request.method = 'POST'; 14801 } 14802} 14803 14804/** 14805 * Header Interceptor. 14806 */ 14807function header (request) { 14808 var headers = assign({}, Http.headers.common, !request.crossOrigin ? Http.headers.custom : {}, Http.headers[toLower(request.method)]); 14809 each(headers, function (value, name) { 14810 if (!request.headers.has(name)) { 14811 request.headers.set(name, value); 14812 } 14813 }); 14814} 14815 14816/** 14817 * XMLHttp client (Browser). 14818 */ 14819function xhrClient (request) { 14820 return new PromiseObj(function (resolve) { 14821 var xhr = new XMLHttpRequest(), 14822 handler = function handler(event) { 14823 var response = request.respondWith('response' in xhr ? xhr.response : xhr.responseText, { 14824 status: xhr.status === 1223 ? 204 : xhr.status, 14825 // IE9 status bug 14826 statusText: xhr.status === 1223 ? 'No Content' : trim(xhr.statusText) 14827 }); 14828 each(trim(xhr.getAllResponseHeaders()).split('\n'), function (row) { 14829 response.headers.append(row.slice(0, row.indexOf(':')), row.slice(row.indexOf(':') + 1)); 14830 }); 14831 resolve(response); 14832 }; 14833 14834 request.abort = function () { 14835 return xhr.abort(); 14836 }; 14837 14838 xhr.open(request.method, request.getUrl(), true); 14839 14840 if (request.timeout) { 14841 xhr.timeout = request.timeout; 14842 } 14843 14844 if (request.responseType && 'responseType' in xhr) { 14845 xhr.responseType = request.responseType; 14846 } 14847 14848 if (request.withCredentials || request.credentials) { 14849 xhr.withCredentials = true; 14850 } 14851 14852 if (!request.crossOrigin) { 14853 request.headers.set('X-Requested-With', 'XMLHttpRequest'); 14854 } // deprecated use downloadProgress 14855 14856 14857 if (isFunction(request.progress) && request.method === 'GET') { 14858 xhr.addEventListener('progress', request.progress); 14859 } 14860 14861 if (isFunction(request.downloadProgress)) { 14862 xhr.addEventListener('progress', request.downloadProgress); 14863 } // deprecated use uploadProgress 14864 14865 14866 if (isFunction(request.progress) && /^(POST|PUT)$/i.test(request.method)) { 14867 xhr.upload.addEventListener('progress', request.progress); 14868 } 14869 14870 if (isFunction(request.uploadProgress) && xhr.upload) { 14871 xhr.upload.addEventListener('progress', request.uploadProgress); 14872 } 14873 14874 request.headers.forEach(function (value, name) { 14875 xhr.setRequestHeader(name, value); 14876 }); 14877 xhr.onload = handler; 14878 xhr.onabort = handler; 14879 xhr.onerror = handler; 14880 xhr.ontimeout = handler; 14881 xhr.send(request.getBody()); 14882 }); 14883} 14884 14885/** 14886 * Http client (Node). 14887 */ 14888function nodeClient (request) { 14889 var client =
vendor: 10,523 bytes, lines 14889-15364
14889__webpack_require__(6608); 14890 14891 return new PromiseObj(function (resolve) { 14892 var url = request.getUrl(); 14893 var body = request.getBody(); 14894 var method = request.method; 14895 var headers = {}, 14896 handler; 14897 request.headers.forEach(function (value, name) { 14898 headers[name] = value; 14899 }); 14900 client(url, { 14901 body: body, 14902 method: method, 14903 headers: headers 14904 }).then(handler = function handler(resp) { 14905 var response = request.respondWith(resp.body, { 14906 status: resp.statusCode, 14907 statusText: trim(resp.statusMessage) 14908 }); 14909 each(resp.headers, function (value, name) { 14910 response.headers.set(name, value); 14911 }); 14912 resolve(response); 14913 }, function (error$$1) { 14914 return handler(error$$1.response); 14915 }); 14916 }); 14917} 14918 14919/** 14920 * Base client. 14921 */ 14922function Client (context) { 14923 var reqHandlers = [sendRequest], 14924 resHandlers = []; 14925 14926 if (!isObject(context)) { 14927 context = null; 14928 } 14929 14930 function Client(request) { 14931 while (reqHandlers.length) { 14932 var handler = reqHandlers.pop(); 14933 14934 if (isFunction(handler)) { 14935 var _ret = function () { 14936 var response = void 0, 14937 next = void 0; 14938 response = handler.call(context, request, function (val) { 14939 return next = val; 14940 }) || next; 14941 14942 if (isObject(response)) { 14943 return { 14944 v: new PromiseObj(function (resolve, reject) { 14945 resHandlers.forEach(function (handler) { 14946 response = when(response, function (response) { 14947 return handler.call(context, response) || response; 14948 }, reject); 14949 }); 14950 when(response, resolve, reject); 14951 }, context) 14952 }; 14953 } 14954 14955 if (isFunction(response)) { 14956 resHandlers.unshift(response); 14957 } 14958 }(); 14959 14960 if (typeof _ret === "object") return _ret.v; 14961 } else { 14962 warn("Invalid interceptor of type " + typeof handler + ", must be a function"); 14963 } 14964 } 14965 } 14966 14967 Client.use = function (handler) { 14968 reqHandlers.push(handler); 14969 }; 14970 14971 return Client; 14972} 14973 14974function sendRequest(request) { 14975 var client = request.client || (inBrowser ? xhrClient : nodeClient); 14976 return client(request); 14977} 14978 14979/** 14980 * HTTP Headers. 14981 */ 14982 14983var Headers = /*#__PURE__*/function () { 14984 function Headers(headers) { 14985 var _this = this; 14986 14987 this.map = {}; 14988 each(headers, function (value, name) { 14989 return _this.append(name, value); 14990 }); 14991 } 14992 14993 var _proto = Headers.prototype; 14994 14995 _proto.has = function has(name) { 14996 return getName(this.map, name) !== null; 14997 }; 14998 14999 _proto.get = function get(name) { 15000 var list = this.map[getName(this.map, name)]; 15001 return list ? list.join() : null; 15002 }; 15003 15004 _proto.getAll = function getAll(name) { 15005 return this.map[getName(this.map, name)] || []; 15006 }; 15007 15008 _proto.set = function set(name, value) { 15009 this.map[normalizeName(getName(this.map, name) || name)] = [trim(value)]; 15010 }; 15011 15012 _proto.append = function append(name, value) { 15013 var list = this.map[getName(this.map, name)]; 15014 15015 if (list) { 15016 list.push(trim(value)); 15017 } else { 15018 this.set(name, value); 15019 } 15020 }; 15021 15022 _proto["delete"] = function _delete(name) { 15023 delete this.map[getName(this.map, name)]; 15024 }; 15025 15026 _proto.deleteAll = function deleteAll() { 15027 this.map = {}; 15028 }; 15029 15030 _proto.forEach = function forEach(callback, thisArg) { 15031 var _this2 = this; 15032 15033 each(this.map, function (list, name) { 15034 each(list, function (value) { 15035 return callback.call(thisArg, value, name, _this2); 15036 }); 15037 }); 15038 }; 15039 15040 return Headers; 15041}(); 15042 15043function getName(map, name) { 15044 return Object.keys(map).reduce(function (prev, curr) { 15045 return toLower(name) === toLower(curr) ? curr : prev; 15046 }, null); 15047} 15048 15049function normalizeName(name) { 15050 if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) { 15051 throw new TypeError('Invalid character in header field name'); 15052 } 15053 15054 return trim(name); 15055} 15056 15057/** 15058 * HTTP Response. 15059 */ 15060 15061var Response = /*#__PURE__*/function () { 15062 function Response(body, _ref) { 15063 var url = _ref.url, 15064 headers = _ref.headers, 15065 status = _ref.status, 15066 statusText = _ref.statusText; 15067 this.url = url; 15068 this.ok = status >= 200 && status < 300; 15069 this.status = status || 0; 15070 this.statusText = statusText || ''; 15071 this.headers = new Headers(headers); 15072 this.body = body; 15073 15074 if (isString(body)) { 15075 this.bodyText = body; 15076 } else if (isBlob(body)) { 15077 this.bodyBlob = body; 15078 15079 if (isBlobText(body)) { 15080 this.bodyText = blobText(body); 15081 } 15082 } 15083 } 15084 15085 var _proto = Response.prototype; 15086 15087 _proto.blob = function blob() { 15088 return when(this.bodyBlob); 15089 }; 15090 15091 _proto.text = function text() { 15092 return when(this.bodyText); 15093 }; 15094 15095 _proto.json = function json() { 15096 return when(this.text(), function (text) { 15097 return JSON.parse(text); 15098 }); 15099 }; 15100 15101 return Response; 15102}(); 15103Object.defineProperty(Response.prototype, 'data', { 15104 get: function get() { 15105 return this.body; 15106 }, 15107 set: function set(body) { 15108 this.body = body; 15109 } 15110}); 15111 15112function blobText(body) { 15113 return new PromiseObj(function (resolve) { 15114 var reader = new FileReader(); 15115 reader.readAsText(body); 15116 15117 reader.onload = function () { 15118 resolve(reader.result); 15119 }; 15120 }); 15121} 15122 15123function isBlobText(body) { 15124 return body.type.indexOf('text') === 0 || body.type.indexOf('json') !== -1; 15125} 15126 15127/** 15128 * HTTP Request. 15129 */ 15130 15131var Request = /*#__PURE__*/function () { 15132 function Request(options$$1) { 15133 this.body = null; 15134 this.params = {}; 15135 assign(this, options$$1, { 15136 method: toUpper(options$$1.method || 'GET') 15137 }); 15138 15139 if (!(this.headers instanceof Headers)) { 15140 this.headers = new Headers(this.headers); 15141 } 15142 } 15143 15144 var _proto = Request.prototype; 15145 15146 _proto.getUrl = function getUrl() { 15147 return Url(this); 15148 }; 15149 15150 _proto.getBody = function getBody() { 15151 return this.body; 15152 }; 15153 15154 _proto.respondWith = function respondWith(body, options$$1) { 15155 return new Response(body, assign(options$$1 || {}, { 15156 url: this.getUrl() 15157 })); 15158 }; 15159 15160 return Request; 15161}(); 15162 15163/** 15164 * Service for sending network requests. 15165 */ 15166var COMMON_HEADERS = { 15167 'Accept': 'application/json, text/plain, */*' 15168}; 15169var JSON_CONTENT_TYPE = { 15170 'Content-Type': 'application/json;charset=utf-8' 15171}; 15172function Http(options$$1) { 15173 var self = this || {}, 15174 client = Client(self.$vm); 15175 defaults(options$$1 || {}, self.$options, Http.options); 15176 Http.interceptors.forEach(function (handler) { 15177 if (isString(handler)) { 15178 handler = Http.interceptor[handler]; 15179 } 15180 15181 if (isFunction(handler)) { 15182 client.use(handler); 15183 } 15184 }); 15185 return client(new Request(options$$1)).then(function (response) { 15186 return response.ok ? response : PromiseObj.reject(response); 15187 }, function (response) { 15188 if (response instanceof Error) { 15189 error(response); 15190 } 15191 15192 return PromiseObj.reject(response); 15193 }); 15194} 15195Http.options = {}; 15196Http.headers = { 15197 put: JSON_CONTENT_TYPE, 15198 post: JSON_CONTENT_TYPE, 15199 patch: JSON_CONTENT_TYPE, 15200 "delete": JSON_CONTENT_TYPE, 15201 common: COMMON_HEADERS, 15202 custom: {} 15203}; 15204Http.interceptor = { 15205 before: before, 15206 method: method, 15207 jsonp: jsonp, 15208 json: json, 15209 form: form, 15210 header: header, 15211 cors: cors 15212}; 15213Http.interceptors = ['before', 'method', 'jsonp', 'json', 'form', 'header', 'cors']; 15214['get', 'delete', 'head', 'jsonp'].forEach(function (method$$1) { 15215 Http[method$$1] = function (url, options$$1) { 15216 return this(assign(options$$1 || {}, { 15217 url: url, 15218 method: method$$1 15219 })); 15220 }; 15221}); 15222['post', 'put', 'patch'].forEach(function (method$$1) { 15223 Http[method$$1] = function (url, body, options$$1) { 15224 return this(assign(options$$1 || {}, { 15225 url: url, 15226 method: method$$1, 15227 body: body 15228 })); 15229 }; 15230}); 15231 15232/** 15233 * Service for interacting with RESTful services. 15234 */ 15235function Resource(url, params, actions, options$$1) { 15236 var self = this || {}, 15237 resource = {}; 15238 actions = assign({}, Resource.actions, actions); 15239 each(actions, function (action, name) { 15240 action = merge({ 15241 url: url, 15242 params: assign({}, params) 15243 }, options$$1, action); 15244 15245 resource[name] = function () { 15246 return (self.$http || Http)(opts(action, arguments)); 15247 }; 15248 }); 15249 return resource; 15250} 15251 15252function opts(action, args) { 15253 var options$$1 = assign({}, action), 15254 params = {}, 15255 body; 15256 15257 switch (args.length) { 15258 case 2: 15259 params = args[0]; 15260 body = args[1]; 15261 break; 15262 15263 case 1: 15264 if (/^(POST|PUT|PATCH)$/i.test(options$$1.method)) { 15265 body = args[0]; 15266 } else { 15267 params = args[0]; 15268 } 15269 15270 break; 15271 15272 case 0: 15273 break; 15274 15275 default: 15276 throw 'Expected up to 2 arguments [params, body], got ' + args.length + ' arguments'; 15277 } 15278 15279 options$$1.body = body; 15280 options$$1.params = assign({}, options$$1.params, params); 15281 return options$$1; 15282} 15283 15284Resource.actions = { 15285 get: { 15286 method: 'GET' 15287 }, 15288 save: { 15289 method: 'POST' 15290 }, 15291 query: { 15292 method: 'GET' 15293 }, 15294 update: { 15295 method: 'PUT' 15296 }, 15297 remove: { 15298 method: 'DELETE' 15299 }, 15300 "delete": { 15301 method: 'DELETE' 15302 } 15303}; 15304 15305/** 15306 * Install plugin. 15307 */ 15308 15309function plugin(Vue) { 15310 if (plugin.installed) { 15311 return; 15312 } 15313 15314 Util(Vue); 15315 Vue.url = Url; 15316 Vue.http = Http; 15317 Vue.resource = Resource; 15318 Vue.Promise = PromiseObj; 15319 Object.defineProperties(Vue.prototype, { 15320 $url: { 15321 get: function get() { 15322 return options(Vue.url, this, this.$options.url); 15323 } 15324 }, 15325 $http: { 15326 get: function get() { 15327 return options(Vue.http, this, this.$options.http); 15328 } 15329 }, 15330 $resource: { 15331 get: function get() { 15332 return Vue.resource.bind(this); 15333 } 15334 }, 15335 $promise: { 15336 get: function get() { 15337 var _this = this; 15338 15339 return function (executor) { 15340 return new Vue.Promise(executor, _this); 15341 }; 15342 } 15343 } 15344 }); 15345} 15346 15347if (typeof window !== 'undefined' && window.Vue && !window.Vue.resource) { 15348 window.Vue.use(plugin); 15349} 15350 15351/* harmony default export */ __webpack_exports__.ZP = (plugin); 15352 15353 15354 15355/***/ }), 15356 15357/***/ 538: 15358/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { 15359 15360"use strict"; 15361/* harmony export */ __webpack_require__.d(__webpack_exports__, { 15362/* harmony export */ ZP: function() { return /* binding */ Vue; } 15363/* harmony export */ }); 15364/* unused harmony exports EffectScope, computed, customRef, defineAsyncComponent, defineComponent, del, effectScope, getCurrentInstance, getCurrentScope, h, inject, isProxy, isReactive, isReadonly, isRef, isS
15364hallow, markRaw, mergeDefaults, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, provide, proxyRefs, reactive, readonly, ref, set, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, useAttrs, useCssModule, useCssVars, useListeners, useSlots, version, watch, watchEffect, watchPostEffect, watchSyncEffect */ 15365/*! 15366 * Vue.js v2.7.16 15367 * (c) 2014-2023 Evan You 15368 * Released under the MIT License. 15369 */ 15370var emptyObject = Object.freeze({}); 15371var isArray = Array.isArray; 15372// These helpers produce better VM code in JS engines due to their 15373// explicitness and function inlining. 15374function isUndef(v) { 15375 return v === undefined || v === null; 15376} 15377function isDef(v) { 15378 return v !== undefined && v !== null; 15379} 15380function isTrue(v) { 15381 return v === true; 15382} 15383function isFalse(v) { 15384 return v === false; 15385} 15386/** 15387 * Check if value is primitive. 15388 */ 15389function isPrimitive(value) { 15390 return (typeof value === 'string' || 15391 typeof value === 'number' || 15392 // $flow-disable-line 15393 typeof value === 'symbol' || 15394 typeof value === 'boolean'); 15395} 15396function isFunction(value) { 15397 return typeof value === 'function'; 15398} 15399/** 15400 * Quick object check - this is primarily used to tell 15401 * objects from primitive values when we know the value 15402 * is a JSON-compliant type. 15403 */ 15404function isObject(obj) { 15405 return obj !== null && typeof obj === 'object'; 15406} 15407/** 15408 * Get the raw type string of a value, e.g., [object Object]. 15409 */ 15410var _toString = Object.prototype.toString; 15411function toRawType(value) { 15412 return _toString.call(value).slice(8, -1); 15413} 15414/** 15415 * Strict object type check. Only returns true 15416 * for plain JavaScript objects. 15417 */ 15418function isPlainObject(obj) { 15419 return _toString.call(obj) === '[object Object]'; 15420} 15421function isRegExp(v) { 15422 return _toString.call(v) === '[object RegExp]'; 15423} 15424/** 15425 * Check if val is a valid array index. 15426 */ 15427function isValidArrayIndex(val) { 15428 var n = parseFloat(String(val)); 15429 return n >= 0 && Math.floor(n) === n && isFinite(val); 15430} 15431function isPromise(val) { 15432 return (isDef(val) && 15433 typeof val.then === 'function' && 15434 typeof val.catch === 'function'); 15435} 15436/** 15437 * Convert a value to a string that is actually rendered. 15438 */ 15439function toString(val) { 15440 return val == null 15441 ? '' 15442 : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString) 15443 ? JSON.stringify(val, replacer, 2) 15444 : String(val); 15445} 15446function replacer(_key, val) { 15447 // avoid circular deps from v3 15448 if (val && val.__v_isRef) { 15449 return val.value; 15450 } 15451 return val; 15452} 15453/** 15454 * Convert an input value to a number for persistence. 15455 * If the conversion fails, return original string. 15456 */ 15457function toNumber(val) { 15458 var n = parseFloat(val); 15459 return isNaN(n) ? val : n; 15460} 15461/** 15462 * Make a map and return a function for checking if a key 15463 * is in that map. 15464 */ 15465function makeMap(str, expectsLowerCase) { 15466 var map = Object.create(null); 15467 var list = str.split(','); 15468 for (var i = 0; i < list.length; i++) { 15469 map[list[i]] = true; 15470 } 15471 return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; }; 15472} 15473/** 15474 * Check if a tag is a built-in tag. 15475 */ 15476var isBuiltInTag = makeMap('slot,component', true); 15477/** 15478 * Check if an attribute is a reserved attribute. 15479 */ 15480var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); 15481/** 15482 * Remove an item from an array. 15483 */ 15484function remove$2(arr, item) { 15485 var len = arr.length; 15486 if (len) { 15487 // fast path for the only / last item 15488 if (item === arr[len - 1]) { 15489 arr.length = len - 1; 15490 return; 15491 } 15492 var index = arr.indexOf(item); 15493 if (index > -1) { 15494 return arr.splice(index, 1); 15495 } 15496 } 15497} 15498/** 15499 * Check whether an object has the property. 15500 */ 15501var hasOwnProperty = Object.prototype.hasOwnProperty; 15502function hasOwn(obj, key) { 15503 return hasOwnProperty.call(obj, key); 15504} 15505/** 15506 * Create a cached version of a pure function. 15507 */ 15508function cached(fn) { 15509 var cache = Object.create(null); 15510 return function cachedFn(str) { 15511 var hit = cache[str]; 15512 return hit || (cache[str] = fn(str)); 15513 }; 15514} 15515/** 15516 * Camelize a hyphen-delimited string. 15517 */ 15518var camelizeRE = /-(\w)/g; 15519var camelize = cached(function (str) { 15520 return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); }); 15521}); 15522/** 15523 * Capitalize a string. 15524 */ 15525var capitalize = cached(function (str) { 15526 return str.charAt(0).toUpperCase() + str.slice(1); 15527}); 15528/** 15529 * Hyphenate a camelCase string. 15530 */ 15531var hyphenateRE = /\B([A-Z])/g; 15532var hyphenate = cached(function (str) { 15533 return str.replace(hyphenateRE, '-$1').toLowerCase(); 15534}); 15535/** 15536 * Simple bind polyfill for environments that do not support it, 15537 * e.g., PhantomJS 1.x. Technically, we don't need this anymore 15538 * since native bind is now performant enough in most browsers.
15539 * But removing it would mean breaking code that was able to run in 15540 * PhantomJS 1.x, so this must be kept for backward compatibility. 15541 */ 15542/* istanbul ignore next */ 15543function polyfillBind(fn, ctx) { 15544 function boundFn(a) { 15545 var l = arguments.length; 15546 return l 15547 ? l > 1 15548 ? fn.apply(ctx, arguments) 15549 : fn.call(ctx, a) 15550 : fn.call(ctx); 15551 } 15552 boundFn._length = fn.length; 15553 return boundFn; 15554} 15555function nativeBind(fn, ctx) { 15556 return fn.bind(ctx); 15557} 15558// @ts-expect-error bind cannot be `undefined` 15559var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind; 15560/** 15561 * Convert an Array-like object to a real Array. 15562 */ 15563function toArray(list, start) { 15564 start = start || 0; 15565 var i = list.length - start; 15566 var ret = new Array(i); 15567 while (i--) { 15568 ret[i] = list[i + start]; 15569 } 15570 return ret; 15571} 15572/** 15573 * Mix properties into target object. 15574 */ 15575function extend(to, _from) { 15576 for (var key in _from) { 15577 to[key] = _from[key]; 15578 } 15579 return to; 15580} 15581/** 15582 * Merge an Array of Objects into a single Object. 15583 */ 15584function toObject(arr) { 15585 var res = {}; 15586 for (var i = 0; i < arr.length; i++) { 15587 if (arr[i]) { 15588 extend(res, arr[i]); 15589 } 15590 } 15591 return res; 15592} 15593/* eslint-disable no-unused-vars */ 15594/** 15595 * Perform no operation. 15596 * Stubbing args to make Flow happy without leaving useless transpiled code 15597 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/). 15598 */ 15599function noop(a, b, c) { } 15600/** 15601 * Always return false. 15602 */ 15603var no = function (a, b, c) { return false; }; 15604/* eslint-enable no-unused-vars */ 15605/** 15606 * Return the same value. 15607 */ 15608var identity = function (_) { return _; }; 15609/** 15610 * Generate a string containing static keys from compiler modules. 15611 */ 15612function genStaticKeys$1(modules) { 15613 return modules 15614 .reduce(function (keys, m) { return keys.concat(m.staticKeys || []); }, []) 15615 .join(','); 15616} 15617/** 15618 * Check if two values are loosely equal - that is, 15619 * if they are plain objects, do they have the same shape? 15620 */ 15621function looseEqual(a, b) { 15622 if (a === b) 15623 return true; 15624 var isObjectA = isObject(a); 15625 var isObjectB = isObject(b); 15626 if (isObjectA && isObjectB) { 15627 try { 15628 var isArrayA = Array.isArray(a); 15629 var isArrayB = Array.isArray(b); 15630 if (isArrayA && isArrayB) { 15631 return (a.length === b.length && 15632 a.every(function (e, i) { 15633 return looseEqual(e, b[i]); 15634 })); 15635 } 15636 else if (a instanceof Date && b instanceof Date) { 15637 return a.getTime() === b.getTime(); 15638 } 15639 else if (!isArrayA && !isArrayB) { 15640 var keysA = Object.keys(a); 15641 var keysB = Object.keys(b); 15642 return (keysA.length === keysB.length && 15643 keysA.every(function (key) { 15644 return looseEqual(a[key], b[key]); 15645 })); 15646 } 15647 else { 15648 /* istanbul ignore next */ 15649 return false; 15650 } 15651 } 15652 catch (e) { 15653 /* istanbul ignore next */ 15654 return false; 15655 } 15656 } 15657 else if (!isObjectA && !isObjectB) { 15658 return String(a) === String(b); 15659 } 15660 else { 15661 return false; 15662 } 15663} 15664/** 15665 * Return the first index at which a loosely equal value can be 15666 * found in the array (if value is a plain object, the array must 15667 * contain an object of the same shape), or -1 if it is not present. 15668 */ 15669function looseIndexOf(arr, val) { 15670 for (var i = 0; i < arr.length; i++) { 15671 if (looseEqual(arr[i], val)) 15672 return i; 15673 } 15674 return -1; 15675} 15676/** 15677 * Ensure a function is called only once. 15678 */ 15679function once(fn) { 15680 var called = false; 15681 return function () { 15682 if (!called) { 15683 called = true; 15684 fn.apply(this, arguments); 15685 } 15686 }; 15687} 15688// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill 15689function hasChanged(x, y) { 15690 if (x === y) { 15691 return x === 0 && 1 / x !== 1 / y; 15692 } 15693 else { 15694 return x === x || y === y; 15695 } 15696} 15697 15698var SSR_ATTR = 'data-server-rendered'; 15699var ASSET_TYPES = ['component', 'directive', 'filter']; 15700var LIFECYCLE_HOOKS = [ 15701 'beforeCreate', 15702 'created', 15703 'beforeMount', 15704 'mounted', 15705 'beforeUpdate', 15706 'updated', 15707 'beforeDestroy', 15708 'destroyed', 15709 'activated', 15710 'deactivated', 15711 'errorCaptured', 15712 'serverPrefetch', 15713 'renderTracked', 15714 'renderTriggered' 15715]; 15716
15717var config = { 15718 /** 15719 * Option merge strategies (used in core/util/options) 15720 */ 15721 // $flow-disable-line 15722 optionMergeStrategies: Object.create(null), 15723 /** 15724 * Whether to suppress warnings. 15725 */ 15726 silent: false, 15727 /** 15728 * Show production mode tip message on boot? 15729 */ 15730 productionTip: "production" !== 'production', 15731 /** 15732 * Whether to enable devtools 15733 */ 15734 devtools: "production" !== 'production', 15735 /** 15736 * Whether to record perf 15737 */ 15738 performance: false, 15739 /** 15740 * Error handler for watcher errors 15741 */ 15742 errorHandler: null, 15743 /** 15744 * Warn handler for watcher warns 15745 */ 15746 warnHandler: null, 15747 /** 15748 * Ignore certain custom elements 15749 */ 15750 ignoredElements: [], 15751 /** 15752 * Custom user key aliases for v-on 15753 */ 15754 // $flow-disable-line 15755 keyCodes: Object.create(null), 15756 /** 15757 * Check if a tag is reserved so that it cannot be registered as a 15758 * component. This is platform-dependent and may be overwritten. 15759 */ 15760 isReservedTag: no, 15761 /** 15762 * Check if an attribute is reserved so that it cannot be used as a component 15763 * prop. This is platform-dependent and may be overwritten. 15764 */ 15765 isReservedAttr: no, 15766 /** 15767 * Check if a tag is an unknown element. 15768 * Platform-dependent. 15769 */ 15770 isUnknownElement: no, 15771 /** 15772 * Get the namespace of an element 15773 */ 15774 getTagNamespace: noop, 15775 /** 15776 * Parse the real tag name for the specific platform. 15777 */ 15778 parsePlatformTagName: identity, 15779 /** 15780 * Check if an attribute must be bound using property, e.g. value 15781 * Platform-dependent. 15782 */ 15783 mustUseProp: no, 15784 /** 15785 * Perform updates asynchronously. Intended to be used by Vue Test Utils 15786 * This will significantly reduce performance if set to false. 15787 */ 15788 async: true, 15789 /** 15790 * Exposed for legacy reasons 15791 */ 15792 _lifecycleHooks: LIFECYCLE_HOOKS 15793}; 15794 15795/** 15796 * unicode letters used for parsing html tags, component names and property paths. 15797 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname 15798 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS 15799 */ 15800var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/; 15801/** 15802 * Check if a string starts with $ or _ 15803 */ 15804function isReserved(str) { 15805 var c = (str + '').charCodeAt(0); 15806 return c === 0x24 || c === 0x5f; 15807} 15808/** 15809 * Define a property. 15810 */ 15811function def(obj, key, val, enumerable) { 15812 Object.defineProperty(obj, key, { 15813 value: val, 15814 enumerable: !!enumerable, 15815 writable: true, 15816 configurable: true 15817 }); 15818} 15819/** 15820 * Parse simple path. 15821 */ 15822var bailRE = new RegExp("[^".concat(unicodeRegExp.source, ".$_\\d]")); 15823function parsePath(path) { 15824 if (bailRE.test(path)) { 15825 return; 15826 } 15827 var segments = path.split('.'); 15828 return function (obj) { 15829 for (var i = 0; i < segments.length; i++) { 15830 if (!obj) 15831 return; 15832 obj = obj[segments[i]]; 15833 } 15834 return obj; 15835 }; 15836} 15837 15838// can we use __proto__? 15839var hasProto = '__proto__' in {}; 15840// Browser environment sniffing 15841var inBrowser = typeof window !== 'undefined'; 15842var UA = inBrowser && window.navigator.userAgent.toLowerCase(); 15843var isIE = UA && /msie|trident/.test(UA); 15844var isIE9 = UA && UA.indexOf('msie 9.0') > 0; 15845var isEdge = UA && UA.indexOf('edge/') > 0; 15846UA && UA.indexOf('android') > 0; 15847var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); 15848UA && /chrome\/\d+/.test(UA) && !isEdge; 15849UA && /phantomjs/.test(UA); 15850var isFF = UA && UA.match(/firefox\/(\d+)/); 15851// Firefox has a "watch" function on Object.prototype... 15852// @ts-expect-error firebox support 15853var nativeWatch = {}.watch; 15854var supportsPassive = false; 15855if (inBrowser) { 15856 try { 15857 var opts = {}; 15858 Object.defineProperty(opts, 'passive', { 15859 get: function () { 15860 /* istanbul ignore next */ 15861 supportsPassive = true; 15862 } 15863 }); // https://github.com/facebook/flow/issues/285 15864 window.addEventListener('test-passive', null, opts); 15865 } 15866 catch (e) { } 15867} 15868// this needs to be lazy-evaled because vue may be required before 15869// vue-server-renderer can set VUE_ENV 15870var _isServer; 15871var isServerRendering = function () { 15872 if (_isServer === undefined) { 15873 /* istanbul ignore if */ 15874 if (!inBrowser && typeof __webpack_require__.g !== 'undefined') { 15875 // detect presence of vue-server-renderer and avoid 15876 // Webpack shimming the process 15877 _isServer = 15878 __webpack_require__.g['process'] && __webpack_require__.g['process'].env.VUE_ENV === 'server'; 15879 } 15880 else { 15881 _isServer = false;
15882 } 15883 } 15884 return _isServer; 15885}; 15886// detect devtools 15887var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; 15888/* istanbul ignore next */ 15889function isNative(Ctor) { 15890 return typeof Ctor === 'function' && /native code/.test(Ctor.toString()); 15891} 15892var hasSymbol = typeof Symbol !== 'undefined' && 15893 isNative(Symbol) && 15894 typeof Reflect !== 'undefined' && 15895 isNative(Reflect.ownKeys); 15896var _Set; // $flow-disable-line 15897/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) { 15898 // use native Set when available. 15899 _Set = Set; 15900} 15901else { 15902 // a non-standard Set polyfill that only works with primitive keys. 15903 _Set = /** @class */ (function () { 15904 function Set() { 15905 this.set = Object.create(null); 15906 } 15907 Set.prototype.has = function (key) { 15908 return this.set[key] === true; 15909 }; 15910 Set.prototype.add = function (key) { 15911 this.set[key] = true; 15912 }; 15913 Set.prototype.clear = function () { 15914 this.set = Object.create(null); 15915 }; 15916 return Set; 15917 }()); 15918} 15919 15920var currentInstance = null; 15921/** 15922 * This is exposed for compatibility with v3 (e.g. some functions in VueUse 15923 * relies on it). Do not use this internally, just use `currentInstance`. 15924 * 15925 * @internal this function needs manual type declaration because it relies 15926 * on previously manually authored types from Vue 2 15927 */ 15928function getCurrentInstance() { 15929 return currentInstance && { proxy: currentInstance }; 15930} 15931/** 15932 * @internal 15933 */ 15934function setCurrentInstance(vm) { 15935 if (vm === void 0) { vm = null; } 15936 if (!vm) 15937 currentInstance && currentInstance._scope.off(); 15938 currentInstance = vm; 15939 vm && vm._scope.on(); 15940} 15941 15942/** 15943 * @internal 15944 */ 15945var VNode = /** @class */ (function () { 15946 function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) { 15947 this.tag = tag; 15948 this.data = data; 15949 this.children = children; 15950 this.text = text; 15951 this.elm = elm; 15952 this.ns = undefined; 15953 this.context = context; 15954 this.fnContext = undefined; 15955 this.fnOptions = undefined; 15956 this.fnScopeId = undefined; 15957 this.key = data && data.key; 15958 this.componentOptions = componentOptions; 15959 this.componentInstance = undefined; 15960 this.parent = undefined; 15961 this.raw = false; 15962 this.isStatic = false; 15963 this.isRootInsert = true; 15964 this.isComment = false; 15965 this.isCloned = false; 15966 this.isOnce = false; 15967 this.asyncFactory = asyncFactory; 15968 this.asyncMeta = undefined; 15969 this.isAsyncPlaceholder = false; 15970 } 15971 Object.defineProperty(VNode.prototype, "child", { 15972 // DEPRECATED: alias for componentInstance for backwards compat. 15973 /* istanbul ignore next */ 15974 get: function () { 15975 return this.componentInstance; 15976 }, 15977 enumerable: false, 15978 configurable: true 15979 }); 15980 return VNode; 15981}()); 15982var createEmptyVNode = function (text) { 15983 if (text === void 0) { text = ''; } 15984 var node = new VNode(); 15985 node.text = text; 15986 node.isComment = true; 15987 return node; 15988}; 15989function createTextVNode(val) { 15990 return new VNode(undefined, undefined, undefined, String(val)); 15991} 15992// optimized shallow clone 15993// used for static nodes and slot nodes because they may be reused across 15994// multiple renders, cloning them avoids errors when DOM manipulations rely 15995// on their elm reference. 15996function cloneVNode(vnode) { 15997 var cloned = new VNode(vnode.tag, vnode.data, 15998 // #7975 15999 // clone children array to avoid mutating original in case of cloning 16000 // a child. 16001 vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory); 16002 cloned.ns = vnode.ns; 16003 cloned.isStatic = vnode.isStatic; 16004 cloned.key = vnode.key; 16005 cloned.isComment = vnode.isComment; 16006 cloned.fnContext = vnode.fnContext; 16007 cloned.fnOptions = vnode.fnOptions; 16008 cloned.fnScopeId = vnode.fnScopeId; 16009 cloned.asyncMeta = vnode.asyncMeta; 16010 cloned.isCloned = true; 16011 return cloned; 16012} 16013 16014/* not type checking this file because flow doesn't play well with Proxy */ 16015var initProxy; 16016if (false) { var getHandler_1, hasHandler_1, isBuiltInModifier_1, hasProxy_1, warnReservedPrefix_1, warnNonPresent_1, allowedGlobals_1; } 16017 16018/****************************************************************************** 16019Copyright (c) Microsoft Corporation. 16020 16021Permission to use, copy, modify, and/or distribute this software for any 16022purpose with or without fee is hereby granted. 16023 16024THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 16025REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 16026AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 16027INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 16028LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 16029OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16030PERFORMANCE OF THIS SOFTWARE. 16031***************************************************************************** */ 16032 16033var __assign = function() { 16034 __assign = Object.assign || function __assign(t) { 16035 for (var s, i = 1, n = arguments.length; i < n; i++) { 16036 s = arguments[i]; 16037 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 16038 } 16039 return t; 16040 }; 16041 return __assign.apply(this, arguments); 16042}; 16043 16044typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { 16045 var e = new Error(message); 16046 return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; 16047}; 16048 16049var uid$2 = 0; 16050var pendingCleanupDeps = []; 16051var cleanupDeps = function () { 16052 for (var i = 0; i < pendingCleanupDeps.length; i++) { 16053 var dep = pendingCleanupDeps[i]; 16054 dep.subs = dep.subs.filter(function (s) { return s; }); 16055 dep._pending = false;
16056 } 16057 pendingCleanupDeps.length = 0; 16058}; 16059/** 16060 * A dep is an observable that can have multiple 16061 * directives subscribing to it. 16062 * @internal 16063 */ 16064var Dep = /** @class */ (function () { 16065 function Dep() { 16066 // pending subs cleanup 16067 this._pending = false; 16068 this.id = uid$2++; 16069 this.subs = []; 16070 } 16071 Dep.prototype.addSub = function (sub) { 16072 this.subs.push(sub); 16073 }; 16074 Dep.prototype.removeSub = function (sub) { 16075 // #12696 deps with massive amount of subscribers are extremely slow to 16076 // clean up in Chromium 16077 // to workaround this, we unset the sub for now, and clear them on 16078 // next scheduler flush. 16079 this.subs[this.subs.indexOf(sub)] = null; 16080 if (!this._pending) { 16081 this._pending = true; 16082 pendingCleanupDeps.push(this); 16083 } 16084 }; 16085 Dep.prototype.depend = function (info) { 16086 if (Dep.target) { 16087 Dep.target.addDep(this); 16088 if (false) {} 16089 } 16090 }; 16091 Dep.prototype.notify = function (info) { 16092 // stabilize the subscriber list first 16093 var subs = this.subs.filter(function (s) { return s; }); 16094 if (false) {} 16095 for (var i = 0, l = subs.length; i < l; i++) { 16096 var sub = subs[i]; 16097 if (false) {}
16098 sub.update(); 16099 } 16100 }; 16101 return Dep; 16102}()); 16103// The current target watcher being evaluated. 16104// This is globally unique because only one watcher 16105// can be evaluated at a time. 16106Dep.target = null; 16107var targetStack = []; 16108function pushTarget(target) { 16109 targetStack.push(target); 16110 Dep.target = target; 16111} 16112function popTarget() { 16113 targetStack.pop(); 16114 Dep.target = targetStack[targetStack.length - 1]; 16115} 16116 16117/* 16118 * not type checking this file because flow doesn't play well with 16119 * dynamically accessing methods on Array prototype 16120 */ 16121var arrayProto = Array.prototype; 16122var arrayMethods = Object.create(arrayProto); 16123var methodsToPatch = [ 16124 'push', 16125 'pop', 16126 'shift', 16127 'unshift', 16128 'splice', 16129 'sort', 16130 'reverse' 16131]; 16132/** 16133 * Intercept mutating methods and emit events 16134 */ 16135methodsToPatch.forEach(function (method) { 16136 // cache original method 16137 var original = arrayProto[method]; 16138 def(arrayMethods, method, function mutator() { 16139 var args = []; 16140 for (var _i = 0; _i < arguments.length; _i++) { 16141 args[_i] = arguments[_i]; 16142 } 16143 var result = original.apply(this, args); 16144 var ob = this.__ob__; 16145 var inserted; 16146 switch (method) { 16147 case 'push': 16148 case 'unshift': 16149 inserted = args; 16150 break; 16151 case 'splice': 16152 inserted = args.slice(2); 16153 break; 16154 } 16155 if (inserted) 16156 ob.observeArray(inserted); 16157 // notify change 16158 if (false) {} 16159 else { 16160 ob.dep.notify(); 16161 } 16162 return result; 16163 }); 16164}); 16165 16166var arrayKeys = Object.getOwnPropertyNames(arrayMethods); 16167var NO_INITIAL_VALUE = {}; 16168/** 16169 * In some cases we may want to disable observation inside a component's 16170 * update computation. 16171 */ 16172var shouldObserve = true; 16173function toggleObserving(value) { 16174 shouldObserve = value; 16175} 16176// ssr mock dep 16177var mockDep = { 16178 notify: noop, 16179 depend: noop, 16180 addSub: noop, 16181 removeSub: noop 16182}; 16183/** 16184 * Observer class that is attached to each observed 16185 * object. Once attached, the observer converts the target 16186 * object's property keys into getter/setters that 16187 * collect dependencies and dispatch updates. 16188 */ 16189var Observer = /** @class */ (function () { 16190 function Observer(value, shallow, mock) { 16191 if (shallow === void 0) { shallow = false; } 16192 if (mock === void 0) { mock = false; } 16193 this.value = value; 16194 this.shallow = shallow; 16195 this.mock = mock; 16196 // this.value = value 16197 this.dep = mock ? mockDep : new Dep(); 16198 this.vmCount = 0; 16199 def(value, '__ob__', this); 16200 if (isArray(value)) { 16201 if (!mock) { 16202 if (hasProto) { 16203 value.__proto__ = arrayMethods; 16204 /* eslint-enable no-proto */ 16205 } 16206 else { 16207 for (var i = 0, l = arrayKeys.length; i < l; i++) { 16208 var key = arrayKeys[i]; 16209 def(value, key, arrayMethods[key]); 16210 } 16211 } 16212 } 16213 if (!shallow) { 16214 this.observeArray(value); 16215 } 16216 } 16217 else { 16218 /** 16219 * Walk through all properties and convert them into 16220 * getter/setters. This method should only be called when 16221 * value type is Object. 16222 */ 16223 var keys = Object.keys(value); 16224 for (var i = 0; i < keys.length; i++) { 16225 var key = keys[i]; 16226 defineReactive(value, key, NO_INITIAL_VALUE, undefined, shallow, mock); 16227 } 16228 } 16229 } 16230 /** 16231 * Observe a list of Array items. 16232 */ 16233 Observer.prototype.observeArray = function (value) { 16234 for (var i = 0, l = value.length; i < l; i++) { 16235 observe(value[i], false, this.mock); 16236 } 16237 }; 16238 return Observer; 16239}()); 16240// helpers 16241/** 16242 * Attempt to create an observer instance for a value, 16243 * returns the new observer if successfully observed, 16244 * or the existing observer if the value already has one. 16245 */ 16246function observe(value, shallow, ssrMockReactivity) { 16247 if (value && hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { 16248 return value.__ob__; 16249 } 16250 if (shouldObserve && 16251 (ssrMockReactivity || !isServerRendering()) && 16252 (isArray(value) || isPlainObject(value)) && 16253 Object.isExtensible(value) && 16254 !value.__v_skip /* ReactiveFlags.SKIP */ && 16255 !isRef(value) && 16256 !(value instanceof VNode)) { 16257 return new Observer(value, shallow, ssrMockReactivity); 16258 } 16259} 16260/** 16261 * Define a reactive property on an Object. 16262 */ 16263function defineReactive(obj, key, val, customSetter, shallow, mock, observeEvenIfShallow) { 16264 if (observeEvenIfShallow === void 0) { observeEvenIfShallow = false; } 16265 var dep = new Dep(); 16266 var property = Object.getOwnPropertyDescriptor(obj, key); 16267 if (property && property.configurable === false) { 16268 return; 16269 } 16270 // cater for pre-defined getter/setters 16271 var getter = property && property.get; 16272 var setter = property && property.set; 16273 if ((!getter || setter) && 16274 (val === NO_INITIAL_VALUE || arguments.length === 2)) { 16275 val = obj[key]; 16276 } 16277 var childOb = shallow ? val && val.__ob__ : observe(val, false, mock);
16278 Object.defineProperty(obj, key, { 16279 enumerable: true, 16280 configurable: true, 16281 get: function reactiveGetter() { 16282 var value = getter ? getter.call(obj) : val; 16283 if (Dep.target) { 16284 if (false) {} 16285 else { 16286 dep.depend(); 16287 } 16288 if (childOb) { 16289 childOb.dep.depend(); 16290 if (isArray(value)) { 16291 dependArray(value); 16292 } 16293 } 16294 } 16295 return isRef(value) && !shallow ? value.value : value; 16296 }, 16297 set: function reactiveSetter(newVal) { 16298 var value = getter ? getter.call(obj) : val; 16299 if (!hasChanged(value, newVal)) { 16300 return; 16301 } 16302 if (false) {} 16303 if (setter) { 16304 setter.call(obj, newVal); 16305 } 16306 else if (getter) { 16307 // #7981: for accessor properties without setter 16308 return; 16309 } 16310 else if (!shallow && isRef(value) && !isRef(newVal)) { 16311 value.value = newVal; 16312 return; 16313 } 16314 else { 16315 val = newVal; 16316 } 16317 childOb = shallow ? newVal && newVal.__ob__ : observe(newVal, false, mock); 16318 if (false) {} 16319 else { 16320 dep.notify(); 16321 } 16322 } 16323 }); 16324 return dep; 16325} 16326function set(target, key, val) { 16327 if (false) {} 16328 if (isReadonly(target)) { 16329 false && 0; 16330 return; 16331 } 16332 var ob = target.__ob__; 16333 if (isArray(target) && isValidArrayIndex(key)) { 16334 target.length = Math.max(target.length, key); 16335 target.splice(key, 1, val); 16336 // when mocking for SSR, array methods are not hijacked 16337 if (ob && !ob.shallow && ob.mock) { 16338 observe(val, false, true); 16339 } 16340 return val; 16341 } 16342 if (key in target && !(key in Object.prototype)) { 16343 target[key] = val; 16344 return val; 16345 } 16346 if (target._isVue || (ob && ob.vmCount)) { 16347 false && 16348 0; 16349 return val; 16350 } 16351 if (!ob) { 16352 target[key] = val; 16353 return val; 16354 } 16355 defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock); 16356 if (false) {} 16357 else { 16358 ob.dep.notify(); 16359 } 16360 return val; 16361} 16362function del(target, key) { 16363 if (false) {} 16364 if (isArray(target) && isValidArrayIndex(key)) { 16365 target.splice(key, 1); 16366 return; 16367 } 16368 var ob = target.__ob__; 16369 if (target._isVue || (ob && ob.vmCount)) { 16370 false && 16371 0; 16372 return; 16373 } 16374 if (isReadonly(target)) { 16375 false && 16376 0; 16377 return; 16378 } 16379 if (!hasOwn(target, key)) { 16380 return; 16381 } 16382 delete target[key]; 16383 if (!ob) { 16384 return; 16385 } 16386 if (false) {} 16387 else { 16388 ob.dep.notify(); 16389 } 16390} 16391/** 16392 * Collect dependencies on array elements when the array is touched, since 16393 * we cannot intercept array element access like property getters. 16394 */ 16395function dependArray(value) { 16396 for (var e = void 0, i = 0, l = value.length; i < l; i++) { 16397 e = value[i]; 16398 if (e && e.__ob__) { 16399 e.__ob__.dep.depend(); 16400 } 16401 if (isArray(e)) { 16402 dependArray(e); 16403 } 16404 } 16405} 16406 16407function reactive(target) { 16408 makeReactive(target, false); 16409 return target; 16410} 16411/** 16412 * Return a shallowly-reactive copy of the original object, where only the root 16413 * level properties are reactive. It also does not auto-unwrap refs (even at the 16414 * root level). 16415 */ 16416function shallowReactive(target) { 16417 makeReactive(target, true); 16418 def(target, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true); 16419 return target; 16420} 16421function makeReactive(target, shallow) { 16422 // if trying to observe a readonly proxy, return the readonly version. 16423 if (!isReadonly(target)) { 16424 if (false) { var existingOb; } 16425 var ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */); 16426 if (false) {} 16427 } 16428} 16429function isReactive(value) { 16430 if (isReadonly(value)) { 16431 return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]); 16432 } 16433 return !!(value && value.__ob__); 16434} 16435function isShallow(value) { 16436 return !!(value && value.__v_isShallow); 16437} 16438function isReadonly(value) { 16439 return !!(value && value.__v_isReadonly); 16440} 16441function isProxy(value) { 16442 return isReactive(value) || isReadonly(value); 16443} 16444function toRaw(observed) { 16445 var raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */]; 16446 return raw ? toRaw(raw) : observed; 16447} 16448function markRaw(value) { 16449 // non-extensible objects won't be observed anyway 16450 if (Object.isExtensible(value)) { 16451 def(value, "__v_skip" /* ReactiveFlags.SKIP */, true); 16452 } 16453 return value; 16454} 16455/** 16456 * @internal 16457 */ 16458function isCollectionType(value) { 16459 var type = toRawType(value); 16460 return (type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet'); 16461} 16462 16463/** 16464 * @internal 16465 */ 16466var RefFlag = "__v_isRef"; 16467function isRef(r) { 16468 return !!(r && r.__v_isRef === true); 16469} 16470function ref$1(value) { 16471 return createRef(value, false); 16472} 16473function shallowRef(value) { 16474 return createRef(value, true); 16475} 16476function createRef(rawValue, shallow) { 16477 if (isRef(rawValue)) { 16478 return rawValue; 16479 } 16480 var ref = {}; 16481 def(ref, RefFlag, true); 16482 def(ref, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, shallow); 16483 def(ref, 'dep', defineReactive(ref, 'value', rawValue, null, shallow, isServerRendering())); 16484 return ref; 16485} 16486function triggerRef(ref) { 16487 if (false) {} 16488 if (false) {} 16489 else { 16490 ref.dep && ref.dep.notify(); 16491 } 16492} 16493function unref(ref) { 16494 return isRef(ref) ? ref.value : ref; 16495} 16496function proxyRefs(objectWithRefs) { 16497 if (isReactive(objectWithRefs)) { 16498 return objectWithRefs; 16499 } 16500 var proxy = {}; 16501 var keys = Object.keys(objectWithRefs); 16502 for (var i = 0; i < keys.length; i++) { 16503 proxyWithRefUnwrap(proxy, objectWithRefs, keys[i]); 16504 } 16505 return proxy; 16506} 16507function proxyWithRefUnwrap(target, source, key) { 16508 Object.defineProperty(target, key, { 16509 enumerable: true, 16510 configurable: true, 16511 get: function () { 16512 var val = source[key]; 16513 if (isRef(val)) { 16514 return val.value; 16515 } 16516 else { 16517 var ob = val && val.__ob__; 16518 if (ob) 16519 ob.dep.depend(); 16520 return val; 16521 } 16522 }, 16523 set: function (value) { 16524 var oldValue = source[key]; 16525 if (isRef(oldValue) && !isRef(value)) { 16526 oldValue.value = value; 16527 } 16528 else { 16529 source[key] = value; 16530 } 16531 } 16532 }); 16533} 16534function customRef(factory) { 16535 var dep = new Dep(); 16536 var _a = factory(function () { 16537 if (false) {} 16538 else { 16539 dep.depend(); 16540 } 16541 }, function () { 16542 if (false) {} 16543 else { 16544 dep.notify(); 16545 } 16546 }), get = _a.get, set = _a.set; 16547 var ref = { 16548 get value() { 16549 return get(); 16550 }, 16551 set value(newVal) { 16552 set(newVal); 16553 } 16554 }; 16555 def(ref, RefFlag, true); 16556 return ref; 16557} 16558function toRefs(object) { 16559 if (false) {} 16560 var ret = isArray(object) ? new Array(object.length) : {}; 16561 for (var key in object) { 16562 ret[key] = toRef(object, key); 16563 } 16564 return ret; 16565} 16566function toRef(object, key, defaultValue) { 16567 var val = object[key]; 16568 if (isRef(val)) { 16569 return val; 16570 } 16571 var ref = { 16572 get value() { 16573 var val = object[key]; 16574 return val === undefined ? defaultValue : val; 16575 }, 16576 set value(newVal) { 16577 object[key] = newVal; 16578 } 16579 }; 16580 def(ref, RefFlag, true); 16581 return ref; 16582} 16583 16584var rawToReadonlyFlag = "__v_rawToReadonly"; 16585var rawToShallowReadonlyFlag = "__v_rawToShallowReadonly"; 16586function readonly(target) { 16587 return createReadonly(target, false); 16588} 16589function createReadonly(target, shallow) { 16590 if (!isPlainObject(target)) { 16591 if (false) {} 16592 return target; 16593 } 16594 if (false) {} 16595 // already a readonly object 16596 if (isReadonly(target)) { 16597 return target; 16598 } 16599 // already has a readonly proxy 16600 var existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag; 16601 var existingProxy = target[existingFlag]; 16602 if (existingProxy) { 16603 return existingProxy; 16604 } 16605 var proxy = Object.create(Object.getPrototypeOf(target)); 16606 def(target, existingFlag, proxy); 16607 def(proxy, "__v_isReadonly" /* ReactiveFlags.IS_READONLY */, true); 16608 def(proxy, "__v_raw" /* ReactiveFlags.RAW */, target); 16609 if (isRef(target)) { 16610 def(proxy, RefFlag, true); 16611 } 16612 if (shallow || isShallow(target)) { 16613 def(proxy, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true); 16614 } 16615 var keys = Object.keys(target); 16616 for (var i = 0; i < keys.length; i++) { 16617 defineReadonlyProperty(proxy, target, keys[i], shallow); 16618 } 16619 return proxy; 16620} 16621function defineReadonlyProperty(proxy, target, key, shallow) { 16622 Object.defineProperty(proxy, key, { 16623 enumerable: true, 16624 configurable: true, 16625 get: function () { 16626 var val = target[key]; 16627 return shallow || !isPlainObject(val) ? val : readonly(val); 16628 }, 16629 set: function () { 16630 false && 16631 0; 16632 } 16633 }); 16634} 16635/** 16636 * Returns a reactive-copy of the original object, where only the root level 16637 * properties are readonly, and does NOT unwrap refs nor recursively convert 16638 * returned properties. 16639 * This is used for creating the props proxy object for stateful components. 16640 */ 16641function shallowReadonly(target) { 16642 return createReadonly(target, true); 16643} 16644 16645function computed(getterOrOptions, debugOptions) { 16646 var getter; 16647 var setter; 16648 var onlyGetter = isFunction(getterOrOptions); 16649 if (onlyGetter) { 16650 getter = getterOrOptions; 16651 setter = false 16652 ? 0 16653 : noop; 16654 } 16655 else { 16656 getter = getterOrOptions.get; 16657 setter = getterOrOptions.set; 16658 } 16659 var watcher = isServerRendering() 16660 ? null 16661 : new Watcher(currentInstance, getter, noop, { lazy: true }); 16662 if (false) {} 16663 var ref = { 16664 // some libs rely on the presence effect for checking computed refs 16665 // from normal refs, but the implementation doesn't matter 16666 effect: watcher, 16667 get value() { 16668 if (watcher) { 16669 if (watcher.dirty) { 16670 watcher.evaluate(); 16671 } 16672 if (Dep.target) { 16673 if (false) {}
16674 watcher.depend(); 16675 } 16676 return watcher.value; 16677 } 16678 else { 16679 return getter(); 16680 } 16681 }, 16682 set value(newVal) { 16683 setter(newVal); 16684 } 16685 }; 16686 def(ref, RefFlag, true); 16687 def(ref, "__v_isReadonly" /* ReactiveFlags.IS_READONLY */, onlyGetter); 16688 return ref; 16689} 16690 16691var mark; 16692var measure; 16693if (false) { var perf_1; } 16694 16695var normalizeEvent = cached(function (name) { 16696 var passive = name.charAt(0) === '&'; 16697 name = passive ? name.slice(1) : name; 16698 var once = name.charAt(0) === '~'; // Prefixed last, checked first 16699 name = once ? name.slice(1) : name; 16700 var capture = name.charAt(0) === '!'; 16701 name = capture ? name.slice(1) : name; 16702 return { 16703 name: name, 16704 once: once, 16705 capture: capture, 16706 passive: passive 16707 }; 16708}); 16709function createFnInvoker(fns, vm) { 16710 function invoker() { 16711 var fns = invoker.fns; 16712 if (isArray(fns)) { 16713 var cloned = fns.slice(); 16714 for (var i = 0; i < cloned.length; i++) { 16715 invokeWithErrorHandling(cloned[i], null, arguments, vm, "v-on handler"); 16716 } 16717 } 16718 else { 16719 // return handler return value for single handlers 16720 return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler"); 16721 } 16722 } 16723 invoker.fns = fns; 16724 return invoker; 16725} 16726function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) { 16727 var name, cur, old, event; 16728 for (name in on) { 16729 cur = on[name]; 16730 old = oldOn[name]; 16731 event = normalizeEvent(name); 16732 if (isUndef(cur)) { 16733 false && 16734 0; 16735 } 16736 else if (isUndef(old)) { 16737 if (isUndef(cur.fns)) { 16738 cur = on[name] = createFnInvoker(cur, vm); 16739 } 16740 if (isTrue(event.once)) { 16741 cur = on[name] = createOnceHandler(event.name, cur, event.capture); 16742 } 16743 add(event.name, cur, event.capture, event.passive, event.params); 16744 } 16745 else if (cur !== old) { 16746 old.fns = cur; 16747 on[name] = old; 16748 } 16749 } 16750 for (name in oldOn) { 16751 if (isUndef(on[name])) { 16752 event = normalizeEvent(name); 16753 remove(event.name, oldOn[name], event.capture); 16754 } 16755 } 16756} 16757 16758function mergeVNodeHook(def, hookKey, hook) { 16759 if (def instanceof VNode) { 16760 def = def.data.hook || (def.data.hook = {}); 16761 } 16762 var invoker; 16763 var oldHook = def[hookKey]; 16764 function wrappedHook() { 16765 hook.apply(this, arguments); 16766 // important: remove merged hook to ensure it's called only once 16767 // and prevent memory leak 16768 remove$2(invoker.fns, wrappedHook); 16769 } 16770 if (isUndef(oldHook)) { 16771 // no existing hook 16772 invoker = createFnInvoker([wrappedHook]); 16773 } 16774 else { 16775 /* istanbul ignore if */ 16776 if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { 16777 // already a merged invoker 16778 invoker = oldHook; 16779 invoker.fns.push(wrappedHook); 16780 } 16781 else { 16782 // existing plain hook 16783 invoker = createFnInvoker([oldHook, wrappedHook]); 16784 } 16785 } 16786 invoker.merged = true; 16787 def[hookKey] = invoker; 16788} 16789 16790function extractPropsFromVNodeData(data, Ctor, tag) { 16791 // we are only extracting raw values here. 16792 // validation and default values are handled in the child 16793 // component itself. 16794 var propOptions = Ctor.options.props; 16795 if (isUndef(propOptions)) { 16796 return; 16797 } 16798 var res = {}; 16799 var attrs = data.attrs, props = data.props; 16800 if (isDef(attrs) || isDef(props)) { 16801 for (var key in propOptions) { 16802 var altKey = hyphenate(key); 16803 if (false) { var keyInLowerCase; } 16804 checkProp(res, props, key, altKey, true) || 16805 checkProp(res, attrs, key, altKey, false); 16806 } 16807 } 16808 return res; 16809} 16810function checkProp(res, hash, key, altKey, preserve) { 16811 if (isDef(hash)) { 16812 if (hasOwn(hash, key)) { 16813 res[key] = hash[key]; 16814 if (!preserve) { 16815 delete hash[key]; 16816 } 16817 return true; 16818 } 16819 else if (hasOwn(hash, altKey)) { 16820 res[key] = hash[altKey]; 16821 if (!preserve) { 16822 delete hash[altKey]; 16823 } 16824 return true; 16825 } 16826 } 16827 return false;
16828} 16829 16830// The template compiler attempts to minimize the need for normalization by 16831// statically analyzing the template at compile time. 16832// 16833// For plain HTML markup, normalization can be completely skipped because the 16834// generated render function is guaranteed to return Array<VNode>. There are 16835// two cases where extra normalization is needed: 16836// 1. When the children contains components - because a functional component 16837// may return an Array instead of a single root. In this case, just a simple 16838// normalization is needed - if any child is an Array, we flatten the whole 16839// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 16840// because functional components already normalize their own children. 16841function simpleNormalizeChildren(children) { 16842 for (var i = 0; i < children.length; i++) { 16843 if (isArray(children[i])) { 16844 return Array.prototype.concat.apply([], children); 16845 } 16846 } 16847 return children; 16848} 16849// 2. When the children contains constructs that always generated nested Arrays, 16850// e.g. <template>, <slot>, v-for, or when the children is provided by user 16851// with hand-written render functions / JSX. In such cases a full normalization 16852// is needed to cater to all possible types of children values. 16853function normalizeChildren(children) { 16854 return isPrimitive(children) 16855 ? [createTextVNode(children)] 16856 : isArray(children) 16857 ? normalizeArrayChildren(children) 16858 : undefined; 16859} 16860function isTextNode(node) { 16861 return isDef(node) && isDef(node.text) && isFalse(node.isComment); 16862} 16863function normalizeArrayChildren(children, nestedIndex) { 16864 var res = []; 16865 var i, c, lastIndex, last; 16866 for (i = 0; i < children.length; i++) { 16867 c = children[i]; 16868 if (isUndef(c) || typeof c === 'boolean') 16869 continue; 16870 lastIndex = res.length - 1; 16871 last = res[lastIndex]; 16872 // nested 16873 if (isArray(c)) { 16874 if (c.length > 0) { 16875 c = normalizeArrayChildren(c, "".concat(nestedIndex || '', "_").concat(i)); 16876 // merge adjacent text nodes 16877 if (isTextNode(c[0]) && isTextNode(last)) { 16878 res[lastIndex] = createTextVNode(last.text + c[0].text); 16879 c.shift(); 16880 } 16881 res.push.apply(res, c); 16882 } 16883 } 16884 else if (isPrimitive(c)) { 16885 if (isTextNode(last)) { 16886 // merge adjacent text nodes 16887 // this is necessary for SSR hydration because text nodes are 16888 // essentially merged when rendered to HTML strings 16889 res[lastIndex] = createTextVNode(last.text + c); 16890 } 16891 else if (c !== '') { 16892 // convert primitive to vnode 16893 res.push(createTextVNode(c)); 16894 } 16895 } 16896 else { 16897 if (isTextNode(c) && isTextNode(last)) { 16898 // merge adjacent text nodes 16899 res[lastIndex] = createTextVNode(last.text + c.text); 16900 } 16901 else { 16902 // default key for nested array children (likely generated by v-for) 16903 if (isTrue(children._isVList) && 16904 isDef(c.tag) && 16905 isUndef(c.key) && 16906 isDef(nestedIndex)) { 16907 c.key = "__vlist".concat(nestedIndex, "_").concat(i, "__"); 16908 } 16909 res.push(c); 16910 } 16911 } 16912 } 16913 return res; 16914} 16915 16916var SIMPLE_NORMALIZE = 1; 16917var ALWAYS_NORMALIZE = 2; 16918// wrapper function for providing a more flexible interface 16919// without getting yelled at by flow 16920function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) { 16921 if (isArray(data) || isPrimitive(data)) { 16922 normalizationType = children; 16923 children = data; 16924 data = undefined; 16925 } 16926 if (isTrue(alwaysNormalize)) { 16927 normalizationType = ALWAYS_NORMALIZE; 16928 } 16929 return _createElement(context, tag, data, children, normalizationType); 16930} 16931function _createElement(context, tag, data, children, normalizationType) { 16932 if (isDef(data) && isDef(data.__ob__)) { 16933 false && 16934 0; 16935 return createEmptyVNode(); 16936 } 16937 // object syntax in v-bind 16938 if (isDef(data) && isDef(data.is)) { 16939 tag = data.is; 16940 } 16941 if (!tag) { 16942 // in case of component :is set to falsy value 16943 return createEmptyVNode(); 16944 } 16945 // warn against non-primitive key 16946 if (false) {} 16947 // support single function children as default scoped slot 16948 if (isArray(children) && isFunction(children[0])) { 16949 data = data || {}; 16950 data.scopedSlots = { default: children[0] }; 16951 children.length = 0; 16952 } 16953 if (normalizationType === ALWAYS_NORMALIZE) { 16954 children = normalizeChildren(children); 16955 } 16956 else if (normalizationType === SIMPLE_NORMALIZE) { 16957 children = simpleNormalizeChildren(children); 16958 } 16959 var vnode, ns; 16960 if (typeof tag === 'string') { 16961 var Ctor = void 0; 16962 ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag); 16963 if (config.isReservedTag(tag)) { 16964 // platform built-in elements 16965 if (false) {} 16966 vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, c
16966ontext); 16967 } 16968 else if ((!data || !data.pre) && 16969 isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) { 16970 // component 16971 vnode = createComponent(Ctor, data, context, children, tag); 16972 } 16973 else { 16974 // unknown or unlisted namespaced elements 16975 // check at runtime because it may get assigned a namespace when its 16976 // parent normalizes children 16977 vnode = new VNode(tag, data, children, undefined, undefined, context); 16978 } 16979 } 16980 else { 16981 // direct component options / constructor 16982 vnode = createComponent(tag, data, context, children); 16983 } 16984 if (isArray(vnode)) { 16985 return vnode; 16986 } 16987 else if (isDef(vnode)) { 16988 if (isDef(ns)) 16989 applyNS(vnode, ns); 16990 if (isDef(data)) 16991 registerDeepBindings(data); 16992 return vnode; 16993 } 16994 else { 16995 return createEmptyVNode(); 16996 } 16997} 16998function applyNS(vnode, ns, force) { 16999 vnode.ns = ns; 17000 if (vnode.tag === 'foreignObject') { 17001 // use default namespace inside foreignObject 17002 ns = undefined; 17003 force = true; 17004 }
17005 if (isDef(vnode.children)) { 17006 for (var i = 0, l = vnode.children.length; i < l; i++) { 17007 var child = vnode.children[i]; 17008 if (isDef(child.tag) && 17009 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) { 17010 applyNS(child, ns, force); 17011 } 17012 } 17013 } 17014} 17015// ref #5318 17016// necessary to ensure parent re-render when deep bindings like :style and 17017// :class are used on slot nodes 17018function registerDeepBindings(data) { 17019 if (isObject(data.style)) { 17020 traverse(data.style); 17021 } 17022 if (isObject(data.class)) { 17023 traverse(data.class); 17024 } 17025} 17026 17027/** 17028 * Runtime helper for rendering v-for lists. 17029 */ 17030function renderList(val, render) { 17031 var ret = null, i, l, keys, key; 17032 if (isArray(val) || typeof val === 'string') { 17033 ret = new Array(val.length); 17034 for (i = 0, l = val.length; i < l; i++) { 17035 ret[i] = render(val[i], i); 17036 } 17037 } 17038 else if (typeof val === 'number') { 17039 ret = new Array(val); 17040 for (i = 0; i < val; i++) { 17041 ret[i] = render(i + 1, i); 17042 } 17043 } 17044 else if (isObject(val)) { 17045 if (hasSymbol && val[Symbol.iterator]) { 17046 ret = []; 17047 var iterator = val[Symbol.iterator](); 17048 var result = iterator.next(); 17049 while (!result.done) { 17050 ret.push(render(result.value, ret.length)); 17051 result = iterator.next(); 17052 } 17053 } 17054 else { 17055 keys = Object.keys(val); 17056 ret = new Array(keys.length); 17057 for (i = 0, l = keys.length; i < l; i++) { 17058 key = keys[i]; 17059 ret[i] = render(val[key], key, i); 17060 } 17061 } 17062 } 17063 if (!isDef(ret)) { 17064 ret = []; 17065 } 17066 ret._isVList = true; 17067 return ret; 17068} 17069 17070/** 17071 * Runtime helper for rendering <slot> 17072 */
17073function renderSlot(name, fallbackRender, props, bindObject) { 17074 var scopedSlotFn = this.$scopedSlots[name]; 17075 var nodes; 17076 if (scopedSlotFn) { 17077 // scoped slot 17078 props = props || {}; 17079 if (bindObject) { 17080 if (false) {} 17081 props = extend(extend({}, bindObject), props); 17082 } 17083 nodes = 17084 scopedSlotFn(props) || 17085 (isFunction(fallbackRender) ? fallbackRender() : fallbackRender); 17086 } 17087 else { 17088 nodes = 17089 this.$slots[name] || 17090 (isFunction(fallbackRender) ? fallbackRender() : fallbackRender); 17091 } 17092 var target = props && props.slot; 17093 if (target) { 17094 return this.$createElement('template', { slot: target }, nodes); 17095 } 17096 else { 17097 return nodes; 17098 } 17099} 17100 17101/** 17102 * Runtime helper for resolving filters 17103 */ 17104function resolveFilter(id) { 17105 return resolveAsset(this.$options, 'filters', id, true) || identity; 17106} 17107 17108function isKeyNotMatch(expect, actual) { 17109 if (isArray(expect)) { 17110 return expect.indexOf(actual) === -1; 17111 } 17112 else { 17113 return expect !== actual; 17114 } 17115} 17116/** 17117 * Runtime helper for checking keyCodes from config. 17118 * exposed as Vue.prototype._k 17119 * passing in eventKeyName as last argument separately for backwards compat 17120 */ 17121function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) { 17122 var mappedKeyCode = config.keyCodes[key] || builtInKeyCode; 17123 if (builtInKeyName && eventKeyName && !config.keyCodes[key]) { 17124 return isKeyNotMatch(builtInKeyName, eventKeyName); 17125 } 17126 else if (mappedKeyCode) { 17127 return isKeyNotMatch(mappedKeyCode, eventKeyCode); 17128 } 17129 else if (eventKeyName) { 17130 return hyphenate(eventKeyName) !== key; 17131 }
17132 return eventKeyCode === undefined; 17133} 17134 17135/** 17136 * Runtime helper for merging v-bind="object" into a VNode's data. 17137 */ 17138function bindObjectProps(data, tag, value, asProp, isSync) { 17139 if (value) { 17140 if (!isObject(value)) { 17141 false && 17142 0; 17143 } 17144 else { 17145 if (isArray(value)) { 17146 value = toObject(value); 17147 } 17148 var hash = void 0; 17149 var _loop_1 = function (key) { 17150 if (key === 'class' || key === 'style' || isReservedAttribute(key)) { 17151 hash = data; 17152 } 17153 else { 17154 var type = data.attrs && data.attrs.type; 17155 hash = 17156 asProp || config.mustUseProp(tag, type, key) 17157 ? data.domProps || (data.domProps = {}) 17158 : data.attrs || (data.attrs = {}); 17159 } 17160 var camelizedKey = camelize(key); 17161 var hyphenatedKey = hyphenate(key); 17162 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) { 17163 hash[key] = value[key]; 17164 if (isSync) { 17165 var on = data.on || (data.on = {}); 17166 on["update:".concat(key)] = function ($event) { 17167 value[key] = $event; 17168 }; 17169 } 17170 } 17171 }; 17172 for (var key in value) { 17173 _loop_1(key); 17174 } 17175 } 17176 } 17177 return data; 17178} 17179 17180/** 17181 * Runtime helper for rendering static trees. 17182 */
17183function renderStatic(index, isInFor) { 17184 var cached = this._staticTrees || (this._staticTrees = []); 17185 var tree = cached[index]; 17186 // if has already-rendered static tree and not inside v-for, 17187 // we can reuse the same tree. 17188 if (tree && !isInFor) { 17189 return tree; 17190 } 17191 // otherwise, render a fresh tree. 17192 tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, this._c, this // for render fns generated for functional component templates 17193 ); 17194 markStatic$1(tree, "__static__".concat(index), false); 17195 return tree; 17196} 17197/** 17198 * Runtime helper for v-once. 17199 * Effectively it means marking the node as static with a unique key. 17200 */ 17201function markOnce(tree, index, key) { 17202 markStatic$1(tree, "__once__".concat(index).concat(key ? "_".concat(key) : ""), true); 17203 return tree; 17204} 17205function markStatic$1(tree, key, isOnce) { 17206 if (isArray(tree)) { 17207 for (var i = 0; i < tree.length; i++) { 17208 if (tree[i] && typeof tree[i] !== 'string') { 17209 markStaticNode(tree[i], "".concat(key, "_").concat(i), isOnce); 17210 } 17211 } 17212 } 17213 else { 17214 markStaticNode(tree, key, isOnce); 17215 } 17216} 17217function markStaticNode(node, key, isOnce) { 17218 node.isStatic = true; 17219 node.key = key; 17220 node.isOnce = isOnce; 17221} 17222 17223function bindObjectListeners(data, value) { 17224 if (value) { 17225 if (!isPlainObject(value)) { 17226 false && 0; 17227 } 17228 else { 17229 var on = (data.on = data.on ? extend({}, data.on) : {}); 17230 for (var key in value) { 17231 var existing = on[key]; 17232 var ours = value[key]; 17233 on[key] = existing ? [].concat(existing, ours) : ours; 17234 } 17235 } 17236 } 17237 return data; 17238} 17239 17240function resolveScopedSlots(fns, res, 17241// the following are added in 2.6 17242hasDynamicKeys, contentHashKey) { 17243 res = res || { $stable: !hasDynamicKeys }; 17244 for (var i = 0; i < fns.length; i++) { 17245 var slot = fns[i]; 17246 if (isArray(slot)) { 17247 resolveScopedSlots(slot, res, hasDynamicKeys); 17248 } 17249 else if (slot) { 17250 // marker for reverse proxying v-slot without scope on this.$slots 17251 // @ts-expect-error 17252 if (slot.proxy) { 17253 // @ts-expect-error 17254 slot.fn.proxy = true; 17255 } 17256 res[slot.key] = slot.fn; 17257 } 17258 } 17259 if (contentHashKey) { 17260 res.$key = contentHashKey; 17261 } 17262 return res; 17263} 17264 17265// helper to process dynamic keys for dynamic arguments in v-bind and v-on. 17266function bindDynamicKeys(baseObj, values) { 17267 for (var i = 0; i < values.length; i += 2) { 17268 var key = values[i]; 17269 if (typeof key === 'string' && key) { 17270 baseObj[values[i]] = values[i + 1]; 17271 } 17272 else if (false) {} 17273 } 17274 return baseObj; 17275} 17276// helper to dynamically append modifier runtime markers to event names. 17277// ensure only append when value is already string, otherwise it will be cast 17278// to string and cause the type check to miss. 17279function prependModifier(value, symbol) { 17280 return typeof value === 'string' ? symbol + value : value; 17281} 17282 17283function installRenderHelpers(target) { 17284 target._o = markOnce; 17285 target._n = toNumber; 17286 target._s = toString; 17287 target._l = renderList; 17288 target._t = renderSlot; 17289 target._q = looseEqual; 17290 target._i = looseIndexOf; 17291 target._m = renderStatic; 17292 target._f = resolveFilter; 17293 target._k = checkKeyCodes; 17294 target._b = bindObjectProps; 17295 target._v = createTextVNode; 17296 target._e = createEmptyVNode; 17297 target._u = resolveScopedSlots; 17298 target._g = bindObjectListeners; 17299 target._d = bindDynamicKeys; 17300 target._p = prependModifier; 17301} 17302 17303/** 17304 * Runtime helper for resolving raw children VNodes into a slot object. 17305 */ 17306function resolveSlots(children, context) { 17307 if (!children || !children.length) { 17308 return {}; 17309 } 17310 var slots = {}; 17311 for (var i = 0, l = children.length; i < l; i++) { 17312 var child = children[i]; 17313 var data = child.data; 17314 // remove slot attribute if the node is resolved as a Vue slot node 17315 if (data && data.attrs && data.attrs.slot) { 17316 delete data.attrs.slot; 17317 } 17318 // named slots should only be respected if the vnode was rendered in the 17319 // same context. 17320 if ((child.context === context || child.fnContext === context) && 17321 data && 17322 data.slot != null) { 17323 var name_1 = data.slot; 17324 var slot = slots[name_1] || (slots[name_1] = []); 17325 if (child.tag === 'template') { 17326 slot.push.apply(slot, child.children || []); 17327 } 17328 else { 17329 slot.push(child); 17330 } 17331 } 17332 else { 17333 (slots.default || (slots.default = [])).push(child); 17334 } 17335 } 17336 // ignore slots that contains only whitespace 17337 for (var name_2 in slots) { 17338 if (slots[name_2].every(isWhitespace)) { 17339 delete slots[name_2]; 17340 } 17341 } 17342 return slots; 17343} 17344function isWhitespace(node) { 17345 return (node.isComment && !node.asyncFactory) || node.text === ' '; 17346} 17347 17348function isAsyncPlaceholder(node) { 17349 // @ts-expect-error not really boolean type 17350 return node.isComment && node.asyncFactory; 17351} 17352 17353function normalizeScopedSlots(ownerVm, scopedSlots, normalSlots, prevScopedSlots) { 17354 var res; 17355 var hasNormalSlots = Object.keys(normalSlots).length > 0; 17356 var isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots; 17357 var key = scopedSlots && scopedSlots.$key; 17358 if (!scopedSlots) { 17359 res = {}; 17360 } 17361 else if (scopedSlots._normalized) { 17362 // fast path 1: child component re-render only, parent did not change 17363 return scopedSlots._normalized; 17364 } 17365 else if (isStable && 17366 prevScopedSlots && 17367 prevScopedSlots !== emptyObject && 17368 key === prevScopedSlots.$key && 17369 !hasNormalSlots && 17370 !prevScopedSlots.$hasNormal) { 17371 // fast path 2: stable scoped slots w/ no normal slots to proxy, 17372 // only need to normalize once 17373 return prevScopedSlots; 17374 } 17375 else { 17376 res = {}; 17377 for (var key_1 in scopedSlots) { 17378 if (scopedSlots[key_1] && key_1[0] !== '$') { 17379 res[key_1] = normalizeScopedSlot(ownerVm, normalSlots, key_1, scopedSlots[key_1]); 17380 } 17381 } 17382 } 17383 // expose normal slots on scopedSlots 17384 for (var key_2 in normalSlots) { 17385 if (!(key_2 in res)) { 17386 res[key_2] = proxyNormalSlot(normalSlots, key_2); 17387 } 17388 }
17389 // avoriaz seems to mock a non-extensible $scopedSlots object 17390 // and when that is passed down this would cause an error 17391 if (scopedSlots && Object.isExtensible(scopedSlots)) { 17392 scopedSlots._normalized = res; 17393 } 17394 def(res, '$stable', isStable); 17395 def(res, '$key', key); 17396 def(res, '$hasNormal', hasNormalSlots); 17397 return res; 17398} 17399function normalizeScopedSlot(vm, normalSlots, key, fn) { 17400 var normalized = function () { 17401 var cur = currentInstance; 17402 setCurrentInstance(vm); 17403 var res = arguments.length ? fn.apply(null, arguments) : fn({}); 17404 res = 17405 res && typeof res === 'object' && !isArray(res) 17406 ? [res] // single vnode 17407 : normalizeChildren(res); 17408 var vnode = res && res[0]; 17409 setCurrentInstance(cur); 17410 return res && 17411 (!vnode || 17412 (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391 17413 ? undefined 17414 : res; 17415 }; 17416 // this is a slot using the new v-slot syntax without scope. although it is 17417 // compiled as a scoped slot, render fn users would expect it to be present 17418 // on this.$slots because the usage is semantically a normal slot. 17419 if (fn.proxy) { 17420 Object.defineProperty(normalSlots, key, { 17421 get: normalized, 17422 enumerable: true, 17423 configurable: true 17424 }); 17425 } 17426 return normalized; 17427} 17428function proxyNormalSlot(slots, key) { 17429 return function () { return slots[key]; }; 17430} 17431 17432function initSetup(vm) { 17433 var options = vm.$options; 17434 var setup = options.setup; 17435 if (setup) { 17436 var ctx = (vm._setupContext = createSetupContext(vm)); 17437 setCurrentInstance(vm); 17438 pushTarget(); 17439 var setupResult = invokeWithErrorHandling(setup, null, [vm._props || shallowReactive({}), ctx], vm, "setup"); 17440 popTarget(); 17441 setCurrentInstance(); 17442 if (isFunction(setupResult)) { 17443 // render function 17444 // @ts-ignore 17445 options.render = setupResult; 17446 } 17447 else if (isObject(setupResult)) { 17448 // bindings 17449 if (false) {} 17450 vm._setupState = setupResult; 17451 // __sfc indicates compiled bindings from <script setup> 17452 if (!setupResult.__sfc) { 17453 for (var key in setupResult) { 17454 if (!isReserved(key)) { 17455 proxyWithRefUnwrap(vm, setupResult, key); 17456 } 17457 else if (false) {} 17458 } 17459 } 17460 else { 17461 // exposed for compiled render fn 17462 var proxy = (vm._setupProxy = {}); 17463 for (var key in setupResult) { 17464 if (key !== '__sfc') { 17465 proxyWithRefUnwrap(proxy, setupResult, key); 17466 } 17467 } 17468 } 17469 } 17470 else if (false) {} 17471 } 17472} 17473function createSetupContext(vm) { 17474 var exposeCalled = false; 17475 return { 17476 get attrs() { 17477 if (!vm._attrsProxy) { 17478 var proxy = (vm._attrsProxy = {}); 17479 def(proxy, '_v_attr_proxy', true); 17480 syncSetupProxy(proxy, vm.$attrs, emptyObject, vm, '$attrs'); 17481 } 17482 return vm._attrsProxy; 17483 }, 17484 get listeners() { 17485 if (!vm._listenersProxy) { 17486 var proxy = (vm._listenersProxy = {}); 17487 syncSetupProxy(proxy, vm.$listeners, emptyObject, vm, '$listeners'); 17488 } 17489 return vm._listenersProxy; 17490 }, 17491 get slots() { 17492 return initSlotsProxy(vm); 17493 }, 17494 emit: bind$1(vm.$emit, vm), 17495 expose: function (exposed) { 17496 if (false) {} 17497 if (exposed) { 17498 Object.keys(exposed).forEach(function (key) { 17499 return proxyWithRefUnwrap(vm, exposed, key); 17500 }); 17501 } 17502 } 17503 }; 17504} 17505function syncSetupProxy(to, from, prev, instance, type) { 17506 var changed = false; 17507 for (var key in from) { 17508 if (!(key in to)) { 17509 changed = true; 17510 defineProxyAttr(to, key, instance, type); 17511 } 17512 else if (from[key] !== prev[key]) { 17513 changed = true; 17514 } 17515 } 17516 for (var key in to) { 17517 if (!(key in from)) { 17518 changed = true; 17519 delete to[key]; 17520 } 17521 } 17522 return changed; 17523} 17524function defineProxyAttr(proxy, key, instance, type) { 17525 Object.defineProperty(proxy, key, { 17526 enumerable: true, 17527 configurable: true, 17528 get: function () { 17529 return instance[type][key]; 17530 } 17531 }); 17532} 17533function initSlotsProxy(vm) { 17534 if (!vm._slotsProxy) { 17535 syncSetupSlots((vm._slotsProxy = {}), vm.$scopedSlots); 17536 } 17537 return vm._slotsProxy; 17538} 17539function syncSetupSlots(to, from) { 17540 for (var key in from) { 17541 to[key] = from[key]; 17542 } 17543 for (var key in to) { 17544 if (!(key in from)) { 17545 delete to[key]; 17546 } 17547 } 17548} 17549/** 17550 * @internal use manual type def because public setup context type relies on 17551 * legacy VNode types 17552 */ 17553function useSlots() { 17554 return getContext().slots; 17555} 17556/** 17557 * @internal use manual type def because public setup context type relies on 17558 * legacy VNode types 17559 */ 17560function useAttrs() { 17561 return getContext().attrs; 17562} 17563/** 17564 * Vue 2 only 17565 * @internal use manual type def because public setup context type relies on 17566 * legacy VNode types 17567 */ 17568function useListeners() { 17569 return getContext().listeners; 17570} 17571function getContext() { 17572 if (false) {} 17573 var vm = currentInstance; 17574 return vm._setupContext || (vm._setupContext = createSetupContext(vm)); 17575} 17576/** 17577 * Runtime helper for merging default declarations. Imported by compiled code 17578 * only. 17579 * @internal 17580 */ 17581function mergeDefaults(raw, defaults) { 17582 var props = isArray(raw) 17583 ? raw.reduce(function (normalized, p) { return ((normalized[p] = {}), normalized); }, {}) 17584 : raw; 17585 for (var key in defaults) { 17586 var opt = props[key]; 17587 if (opt) { 17588 if (isArray(opt) || isFunction(opt)) { 17589 props[key] = { type: opt, default: defaults[key] }; 17590 } 17591 else { 17592 opt.default = defaults[key]; 17593 } 17594 } 17595 else if (opt === null) { 17596 props[key] = { default: defaults[key] }; 17597 } 17598 else if (false) {} 17599 } 17600 return props; 17601} 17602 17603function initRender(vm) { 17604 vm._vnode = null; // the root of the child tree 17605 vm._staticTrees = null; // v-once cached trees 17606 var options = vm.$options; 17607 var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree 17608 var renderContext = parentVnode && parentVnode.context; 17609 vm.$slots = resolveSlots(options._renderChildren, renderContext); 17610 vm.$scopedSlots = parentVnode 17611 ? normalizeScopedSlots(vm.$parent, parentVnode.data.scopedSlots, vm.$slots) 17612 : emptyObject; 17613 // bind the createElement fn to this instance 17614 // so that we get proper render context inside it. 17615 // args order: tag, data, children, normalizationType, alwaysNormalize 17616 // internal version is used by render functions compiled from templates 17617 // @ts-expect-error 17618 vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); }; 17619 // normalization is always applied for the public version, used in 17620 // user-written render functions. 17621 // @ts-expect-error 17622 vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); }; 17623 // $attrs & $listeners are exposed for easier HOC creation. 17624 // they need to be reactive so that HOCs using them are always updated 17625 var parentData = parentVnode && parentVnode.data; 17626 /* istanbul ignore else */ 17627 if (false) {} 17628 else { 17629 defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true); 17630 defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true); 17631 } 17632} 17633var currentRenderingInstance = null; 17634function renderMixin(Vue) { 17635 // install runtime convenience helpers 17636 installRenderHelpers(Vue.prototype); 17637 Vue.prototype.$nextTick = function (fn) { 17638 return nextTick(fn, this); 17639 }; 17640 Vue.prototype._render = function () { 17641 var vm = this; 17642 var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode; 17643 if (_parentVnode && vm._isMounted) { 17644 vm.$scopedSlots = normalizeScopedSlots(vm.$parent, _parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots); 17645 if (vm._slotsProxy) { 17646 syncSetupSlots(vm._slotsProxy, vm.$scopedSlots); 17647 } 17648 } 17649 // set parent vnode. this allows render functions to have access 17650 // to the data on the placeholder node. 17651 vm.$vnode = _parentVnode; 17652 // render self 17653 var prevInst = currentInstance; 17654 var prevRenderInst = currentRenderingInstance; 17655 var vnode; 17656 try { 17657 setCurrentInstance(vm); 17658 currentRenderingInstance = vm; 17659 vnode = render.call(vm._renderProxy, vm.$createElement); 17660 } 17661 catch (e) { 17662 handleError(e, vm, "render"); 17663 // return error render result, 17664 // or previous vnode to prevent render error causing blank component 17665 /* istanbul ignore else */ 17666 if (false) {} 17667 else { 17668 vnode = vm._vnode; 17669 } 17670 } 17671 finally { 17672 currentRenderingInstance = prevRenderInst; 17673 setCurrentInstance(prevInst); 17674 } 17675 // if the returned array contains only a single node, allow it 17676 if (isArray(vnode) && vnode.length === 1) { 17677 vnode = vnode[0]; 17678 } 17679 // return empty vnode in case the render function errored out 17680 if (!(vnode instanceof VNode)) { 17681 if (false) {} 17682 vnode = createEmptyVNode(); 17683 } 17684 // set parent 17685 vnode.parent = _parentVnode; 17686 return vnode; 17687 }; 17688} 17689 17690function ensureCtor(comp, base) { 17691 if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) { 17692 comp = comp.default; 17693 } 17694 return isObject(comp) ? base.extend(comp) : comp; 17695} 17696function createAsyncPlaceholder(factory, data, context, children, tag) { 17697 var node = createEmptyVNode(); 17698 node.asyncFactory = factory; 17699 node.asyncMeta = { data: data, context: context, children: children, tag: tag }; 17700 return node; 17701} 17702function resolveAsyncComponent(factory, baseCtor) { 17703 if (isTrue(factory.error) && isDef(factory.errorComp)) { 17704 return factory.errorComp; 17705 } 17706 if (isDef(factory.resolved)) { 17707 return factory.resolved; 17708 } 17709 var owner = currentRenderingInstance;
17710 if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) { 17711 // already pending 17712 factory.owners.push(owner); 17713 } 17714 if (isTrue(factory.loading) && isDef(factory.loadingComp)) { 17715 return factory.loadingComp; 17716 } 17717 if (owner && !isDef(factory.owners)) { 17718 var owners_1 = (factory.owners = [owner]); 17719 var sync_1 = true; 17720 var timerLoading_1 = null; 17721 var timerTimeout_1 = null; 17722 owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); }); 17723 var forceRender_1 = function (renderCompleted) { 17724 for (var i = 0, l = owners_1.length; i < l; i++) { 17725 owners_1[i].$forceUpdate(); 17726 } 17727 if (renderCompleted) { 17728 owners_1.length = 0; 17729 if (timerLoading_1 !== null) { 17730 clearTimeout(timerLoading_1); 17731 timerLoading_1 = null; 17732 } 17733 if (timerTimeout_1 !== null) { 17734 clearTimeout(timerTimeout_1); 17735 timerTimeout_1 = null; 17736 } 17737 } 17738 }; 17739 var resolve = once(function (res) { 17740 // cache resolved 17741 factory.resolved = ensureCtor(res, baseCtor); 17742 // invoke callbacks only if this is not a synchronous resolve 17743 // (async resolves are shimmed as synchronous during SSR) 17744 if (!sync_1) { 17745 forceRender_1(true); 17746 } 17747 else { 17748 owners_1.length = 0; 17749 } 17750 }); 17751 var reject_1 = once(function (reason) { 17752 false && 17753 0; 17754 if (isDef(factory.errorComp)) { 17755 factory.error = true; 17756 forceRender_1(true); 17757 } 17758 }); 17759 var res_1 = factory(resolve, reject_1); 17760 if (isObject(res_1)) { 17761 if (isPromise(res_1)) { 17762 // () => Promise 17763 if (isUndef(factory.resolved)) { 17764 res_1.then(resolve, reject_1); 17765 } 17766 } 17767 else if (isPromise(res_1.component)) { 17768 res_1.component.then(resolve, reject_1); 17769 if (isDef(res_1.error)) { 17770 factory.errorComp = ensureCtor(res_1.error, baseCtor); 17771 } 17772 if (isDef(res_1.loading)) { 17773 factory.loadingComp = ensureCtor(res_1.loading, baseCtor); 17774 if (res_1.delay === 0) { 17775 factory.loading = true; 17776 } 17777 else { 17778 // @ts-expect-error NodeJS timeout type 17779 timerLoading_1 = setTimeout(function () { 17780 timerLoading_1 = null; 17781 if (isUndef(factory.resolved) && isUndef(factory.error)) { 17782 factory.loading = true; 17783 forceRender_1(false); 17784 } 17785 }, res_1.delay || 200); 17786 } 17787 } 17788 if (isDef(res_1.timeout)) { 17789 // @ts-expect-error NodeJS timeout type 17790 timerTimeout_1 = setTimeout(function () { 17791 timerTimeout_1 = null; 17792 if (isUndef(factory.resolved)) { 17793 reject_1( false ? 0 : null); 17794 } 17795 }, res_1.timeout); 17796 } 17797 } 17798 } 17799 sync_1 = false; 17800 // return in case resolved synchronously 17801 return factory.loading ? factory.loadingComp : factory.resolved; 17802 } 17803} 17804 17805function getFirstComponentChild(children) { 17806 if (isArray(children)) { 17807 for (var i = 0; i < children.length; i++) { 17808 var c = children[i]; 17809 if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { 17810 return c; 17811 } 17812 } 17813 } 17814} 17815 17816function initEvents(vm) { 17817 vm._events = Object.create(null); 17818 vm._hasHookEvent = false; 17819 // init parent attached events 17820 var listeners = vm.$options._parentListeners; 17821 if (listeners) { 17822 updateComponentListeners(vm, listeners); 17823 } 17824} 17825var target$1; 17826function add$1(event, fn) { 17827 target$1.$on(event, fn); 17828} 17829function remove$1(event, fn) { 17830 target$1.$off(event, fn); 17831} 17832function createOnceHandler$1(event, fn) { 17833 var _target = target$1; 17834 return function onceHandler() { 17835 var res = fn.apply(null, arguments); 17836 if (res !== null) { 17837 _target.$off(event, onceHandler); 17838 } 17839 }; 17840} 17841function updateComponentListeners(vm, listeners, oldListeners) { 17842 target$1 = vm; 17843 updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm); 17844 target$1 = undefined; 17845} 17846function eventsMixin(Vue) { 17847 var hookRE = /^hook:/; 17848 Vue.prototype.$on = function (event, fn) { 17849 var vm = this; 17850 if (isArray(event)) { 17851 for (var i = 0, l = event.length; i < l; i++) { 17852 vm.$on(event[i], fn); 17853 } 17854 } 17855 else { 17856 (vm._events[event] || (vm._events[event] = [])).push(fn); 17857 // optimize hook:event cost by using a boolean flag marked at registration 17858 // instead of a hash lookup 17859 if (hookRE.test(event)) { 17860 vm._hasHookEvent = true; 17861 } 17862 } 17863 return vm; 17864 }; 17865 Vue.prototype.$once = function (event, fn) { 17866 var vm = this; 17867 function on() { 17868 vm.$off(event, on); 17869 fn.apply(vm, arguments); 17870 } 17871 on.fn = fn; 17872 vm.$on(event, on); 17873 return vm; 17874 }; 17875 Vue.prototype.$off = function (event, fn) { 17876 var vm = this; 17877 // all 17878 if (!arguments.length) { 17879 vm._events = Object.create(null); 17880 return vm; 17881 } 17882 // array of events 17883 if (isArray(event)) { 17884 for (var i_1 = 0, l = event.length; i_1 < l; i_1++) { 17885 vm.$off(event[i_1], fn); 17886 } 17887 return vm; 17888 } 17889 // specific event 17890 var cbs = vm._events[event]; 17891 if (!cbs) { 17892 return vm; 17893 } 17894 if (!fn) { 17895 vm._events[event] = null; 17896 return vm; 17897 } 17898 // specific handler 17899 var cb; 17900 var i = cbs.length; 17901 while (i--) { 17902 cb = cbs[i];
17903 if (cb === fn || cb.fn === fn) { 17904 cbs.splice(i, 1); 17905 break; 17906 } 17907 } 17908 return vm; 17909 }; 17910 Vue.prototype.$emit = function (event) { 17911 var vm = this; 17912 if (false) { var lowerCaseEvent; } 17913 var cbs = vm._events[event]; 17914 if (cbs) { 17915 cbs = cbs.length > 1 ? toArray(cbs) : cbs; 17916 var args = toArray(arguments, 1); 17917 var info = "event handler for \"".concat(event, "\""); 17918 for (var i = 0, l = cbs.length; i < l; i++) { 17919 invokeWithErrorHandling(cbs[i], vm, args, vm, info); 17920 } 17921 } 17922 return vm; 17923 }; 17924} 17925 17926var activeEffectScope; 17927var EffectScope = /** @class */ (function () { 17928 function EffectScope(detached) { 17929 if (detached === void 0) { detached = false; } 17930 this.detached = detached; 17931 /** 17932 * @internal 17933 */ 17934 this.active = true; 17935 /** 17936 * @internal 17937 */ 17938 this.effects = []; 17939 /** 17940 * @internal 17941 */ 17942 this.cleanups = []; 17943 this.parent = activeEffectScope; 17944 if (!detached && activeEffectScope) { 17945 this.index = 17946 (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; 17947 } 17948 } 17949 EffectScope.prototype.run = function (fn) { 17950 if (this.active) { 17951 var currentEffectScope = activeEffectScope; 17952 try { 17953 activeEffectScope = this; 17954 return fn(); 17955 } 17956 finally { 17957 activeEffectScope = currentEffectScope; 17958 } 17959 } 17960 else if (false) {} 17961 }; 17962 /** 17963 * This should only be called on non-detached scopes 17964 * @internal 17965 */ 17966 EffectScope.prototype.on = function () { 17967 activeEffectScope = this; 17968 }; 17969 /** 17970 * This should only be called on non-detached scopes 17971 * @internal 17972 */ 17973 EffectScope.prototype.off = function () { 17974 activeEffectScope = this.parent; 17975 }; 17976 EffectScope.prototype.stop = function (fromParent) { 17977 if (this.active) { 17978 var i = void 0, l = void 0; 17979 for (i = 0, l = this.effects.length; i < l; i++) { 17980 this.effects[i].teardown(); 17981 } 17982 for (i = 0, l = this.cleanups.length; i < l; i++) { 17983 this.cleanups[i](); 17984 } 17985 if (this.scopes) { 17986 for (i = 0, l = this.scopes.length; i < l; i++) { 17987 this.scopes[i].stop(true); 17988 } 17989 } 17990 // nested scope, dereference from parent to avoid memory leaks 17991 if (!this.detached && this.parent && !fromParent) { 17992 // optimized O(1) removal 17993 var last = this.parent.scopes.pop(); 17994 if (last && last !== this) { 17995 this.parent.scopes[this.index] = last; 17996 last.index = this.index; 17997 } 17998 } 17999 this.parent = undefined; 18000 this.active = false; 18001 } 18002 }; 18003 return EffectScope; 18004}()); 18005function effectScope(detached) { 18006 return new EffectScope(detached); 18007} 18008/** 18009 * @internal 18010 */ 18011function recordEffectScope(effect, scope) { 18012 if (scope === void 0) { scope = activeEffectScope; } 18013 if (scope && scope.active) { 18014 scope.effects.push(effect); 18015 } 18016} 18017function getCurrentScope() { 18018 return activeEffectScope; 18019} 18020function onScopeDispose(fn) { 18021 if (activeEffectScope) { 18022 activeEffectScope.cleanups.push(fn); 18023 } 18024 else if (false) {} 18025} 18026 18027var activeInstance = null; 18028var isUpdatingChildComponent = false; 18029function setActiveInstance(vm) { 18030 var prevActiveInstance = activeInstance; 18031 activeInstance = vm; 18032 return function () { 18033 activeInstance = prevActiveInstance; 18034 }; 18035} 18036function initLifecycle(vm) { 18037 var options = vm.$options; 18038 // locate first non-abstract parent 18039 var parent = options.parent; 18040 if (parent && !options.abstract) { 18041 while (parent.$options.abstract && parent.$parent) { 18042 parent = parent.$parent; 18043 } 18044 parent.$children.push(vm); 18045 } 18046 vm.$parent = parent; 18047 vm.$root = parent ? parent.$root : vm; 18048 vm.$children = []; 18049 vm.$refs = {}; 18050 vm._provided = parent ? parent._provided : Object.create(null); 18051 vm._watcher = null; 18052 vm._inactive = null; 18053 vm._directInactive = false;
18054 vm._isMounted = false; 18055 vm._isDestroyed = false; 18056 vm._isBeingDestroyed = false; 18057} 18058function lifecycleMixin(Vue) { 18059 Vue.prototype._update = function (vnode, hydrating) { 18060 var vm = this; 18061 var prevEl = vm.$el; 18062 var prevVnode = vm._vnode; 18063 var restoreActiveInstance = setActiveInstance(vm); 18064 vm._vnode = vnode; 18065 // Vue.prototype.__patch__ is injected in entry points 18066 // based on the rendering backend used. 18067 if (!prevVnode) { 18068 // initial render 18069 vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */); 18070 } 18071 else { 18072 // updates 18073 vm.$el = vm.__patch__(prevVnode, vnode); 18074 } 18075 restoreActiveInstance(); 18076 // update __vue__ reference 18077 if (prevEl) { 18078 prevEl.__vue__ = null; 18079 } 18080 if (vm.$el) { 18081 vm.$el.__vue__ = vm; 18082 } 18083 // if parent is an HOC, update its $el as well 18084 var wrapper = vm; 18085 while (wrapper && 18086 wrapper.$vnode && 18087 wrapper.$parent && 18088 wrapper.$vnode === wrapper.$parent._vnode) { 18089 wrapper.$parent.$el = wrapper.$el; 18090 wrapper = wrapper.$parent; 18091 } 18092 // updated hook is called by the scheduler to ensure that children are 18093 // updated in a parent's updated hook. 18094 }; 18095 Vue.prototype.$forceUpdate = function () { 18096 var vm = this; 18097 if (vm._watcher) { 18098 vm._watcher.update(); 18099 } 18100 }; 18101 Vue.prototype.$destroy = function () { 18102 var vm = this; 18103 if (vm._isBeingDestroyed) { 18104 return; 18105 } 18106 callHook$1(vm, 'beforeDestroy'); 18107 vm._isBeingDestroyed = true; 18108 // remove self from parent 18109 var parent = vm.$parent; 18110 if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { 18111 remove$2(parent.$children, vm); 18112 } 18113 // teardown scope. this includes both the render watcher and other 18114 // watchers created 18115 vm._scope.stop(); 18116 // remove reference from data ob 18117 // frozen object may not have observer. 18118 if (vm._data.__ob__) { 18119 vm._data.__ob__.vmCount--; 18120 } 18121 // call the last hook... 18122 vm._isDestroyed = true; 18123 // invoke destroy hooks on current rendered tree 18124 vm.__patch__(vm._vnode, null); 18125 // fire destroyed hook 18126 callHook$1(vm, 'destroyed'); 18127 // turn off all instance listeners. 18128 vm.$off(); 18129 // remove __vue__ reference 18130 if (vm.$el) { 18131 vm.$el.__vue__ = null; 18132 } 18133 // release circular reference (#6759) 18134 if (vm.$vnode) { 18135 vm.$vnode.parent = null; 18136 } 18137 }; 18138} 18139function mountComponent(vm, el, hydrating) { 18140 vm.$el = el; 18141 if (!vm.$options.render) { 18142 // @ts-expect-error invalid type 18143 vm.$options.render = createEmptyVNode; 18144 if (false) {} 18145 } 18146 callHook$1(vm, 'beforeMount'); 18147 var updateComponent; 18148 /* istanbul ignore if */ 18149 if (false) {} 18150 else { 18151 updateComponent = function () { 18152 vm._update(vm._render(), hydrating); 18153 }; 18154 } 18155 var watcherOptions = { 18156 before: function () { 18157 if (vm._isMounted && !vm._isDestroyed) { 18158 callHook$1(vm, 'beforeUpdate'); 18159 } 18160 } 18161 }; 18162 if (false) {} 18163 // we set this to vm._watcher inside the watcher's constructor 18164 // since the watcher's initial patch may call $forceUpdate (e.g. inside child 18165 // component's mounted hook), which relies on vm._watcher being already defined 18166 new Watcher(vm, updateComponent, noop, watcherOptions, true /* isRenderWatcher */); 18167 hydrating = false; 18168 // flush buffer for flush: "pre" watchers queued in setup() 18169 var preWatchers = vm._preWatchers; 18170 if (preWatchers) { 18171 for (var i = 0; i < preWatchers.length; i++) { 18172 preWatchers[i].run(); 18173 } 18174 } 18175 // manually mounted instance, call mounted on self 18176 // mounted is called for render-created child components in its inserted hook 18177 if (vm.$vnode == null) { 18178 vm._isMounted = true; 18179 callHook$1(vm, 'mounted'); 18180 } 18181 return vm; 18182} 18183function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) { 18184 if (false) {} 18185 // determine whether component has slot children 18186 // we need to do this before overwriting $options._renderChildren. 18187 // check if there are dynamic scopedSlots (hand-written or compiled but with 18188 // dynamic slot names). Static scoped slots compiled from template has the 18189 // "$stable" marker. 18190 var newScopedSlots = parentVnode.data.scopedSlots; 18191 var oldScopedSlots = vm.$scopedSlots; 18192 var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) || 18193 (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) || 18194 (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) || 18195 (!newScopedSlots && vm.$scopedSlots.$key)); 18196 // Any static slot children from the parent may have changed during parent's 18197 // update. Dynamic scoped slots may also have changed. In such cases, a forced 18198 // update is necessary to ensure correctness. 18199 var needsForceUpdate = !!(renderChildren || // has new static slots 18200 vm.$options._renderChildren || // has old static slots 18201 hasDynamicScopedSlot); 18202 var prevVNode = vm.$vnode; 18203 vm.$options._parentVnode = parentVnode; 18204 vm.$vnode = parentVnode; // update vm's placeholder node without re-render 18205 if (vm._vnode) { 18206 // update child tree's parent 18207 vm._vnode.parent = parentVnode; 18208 } 18209 vm.$options._renderChildren = renderChildren; 18210 // update $attrs and $listeners hash 18211 // these are also reactive so they may trigger child update if the child 18212 // used them during render 18213 var attrs = parentVnode.data.attrs || emptyObject; 18214 if (vm._attrsProxy) { 18215 // force update if attrs are accessed and has changed since it may be 18216 // passed to a child component. 18217 if (syncSetupProxy(vm._attrsProxy, attrs, (prevVNode.data && prevVNode.data.attrs) || emptyObject, vm, '$attrs')) { 18218 needsForceUpdate = true; 18219 } 18220 } 18221 vm.$attrs = attrs; 18222 // update listeners 18223 listeners = listeners || emptyObject; 18224 var prevListeners = vm.$options._parentListeners; 18225 if (vm._listenersProxy) { 18226 syncSetupProxy(vm._listenersProxy, listeners, prevListeners || emptyObject, vm, '$listeners'); 18227 } 18228 vm.$listeners = vm.$options._parentListeners = listeners; 18229 updateComponentListeners(vm, listeners, prevListeners); 18230 // update props 18231 if (propsData && vm.$options.props) { 18232 toggleObserving(false); 18233 var props = vm._props; 18234 var propKeys = vm.$options._propKeys || []; 18235 for (var i = 0; i < propKeys.length; i++) { 18236 var key = propKeys[i]; 18237 var propOptions = vm.$options.props; // wtf flow? 18238 props[key] = validateProp(key, propOptions, propsData, vm); 18239 } 18240 toggleObserving(true); 18241 // keep a copy of raw propsData 18242 vm.$options.propsData = propsData; 18243 } 18244 // resolve slots + force update if has children 18245 if (needsForceUpdate) { 18246 vm.$slots = resolveSlots(renderChildren, parentVnode.context); 18247 vm.$forceUpdate(); 18248 } 18249 if (false) {} 18250} 18251function isInInactiveTree(vm) { 18252 while (vm && (vm = vm.$parent)) { 18253 if (vm._inactive) 18254 return true; 18255 } 18256 return false;
18257} 18258function activateChildComponent(vm, direct) { 18259 if (direct) { 18260 vm._directInactive = false; 18261 if (isInInactiveTree(vm)) { 18262 return; 18263 } 18264 } 18265 else if (vm._directInactive) { 18266 return; 18267 } 18268 if (vm._inactive || vm._inactive === null) { 18269 vm._inactive = false; 18270 for (var i = 0; i < vm.$children.length; i++) { 18271 activateChildComponent(vm.$children[i]); 18272 } 18273 callHook$1(vm, 'activated'); 18274 } 18275} 18276function deactivateChildComponent(vm, direct) { 18277 if (direct) { 18278 vm._directInactive = true; 18279 if (isInInactiveTree(vm)) { 18280 return; 18281 } 18282 } 18283 if (!vm._inactive) { 18284 vm._inactive = true; 18285 for (var i = 0; i < vm.$children.length; i++) { 18286 deactivateChildComponent(vm.$children[i]); 18287 } 18288 callHook$1(vm, 'deactivated'); 18289 } 18290} 18291function callHook$1(vm, hook, args, setContext) { 18292 if (setContext === void 0) { setContext = true; } 18293 // #7573 disable dep collection when invoking lifecycle hooks 18294 pushTarget(); 18295 var prevInst = currentInstance; 18296 var prevScope = getCurrentScope(); 18297 setContext && setCurrentInstance(vm); 18298 var handlers = vm.$options[hook]; 18299 var info = "".concat(hook, " hook"); 18300 if (handlers) { 18301 for (var i = 0, j = handlers.length; i < j; i++) { 18302 invokeWithErrorHandling(handlers[i], vm, args || null, vm, info); 18303 } 18304 } 18305 if (vm._hasHookEvent) { 18306 vm.$emit('hook:' + hook); 18307 } 18308 if (setContext) { 18309 setCurrentInstance(prevInst); 18310 prevScope && prevScope.on(); 18311 } 18312 popTarget(); 18313} 18314 18315var MAX_UPDATE_COUNT = 100; 18316var queue = []; 18317var activatedChildren = []; 18318var has = {}; 18319var circular = {}; 18320var waiting = false; 18321var flushing = false; 18322var index$1 = 0; 18323/** 18324 * Reset the scheduler's state. 18325 */ 18326function resetSchedulerState() { 18327 index$1 = queue.length = activatedChildren.length = 0; 18328 has = {}; 18329 if (false) {} 18330 waiting = flushing = false; 18331} 18332// Async edge case #6566 requires saving the timestamp when event listeners are 18333// attached. However, calling performance.now() has a perf overhead especially 18334// if the page has thousands of event listeners. Instead, we take a timestamp 18335// every time the scheduler flushes and use that for all event listeners 18336// attached during that flush. 18337var currentFlushTimestamp = 0; 18338// Async edge case fix requires storing an event listener's attach timestamp. 18339var getNow = Date.now; 18340// Determine what event timestamp the browser is using. Annoyingly, the 18341// timestamp can either be hi-res (relative to page load) or low-res 18342// (relative to UNIX epoch), so in order to compare time we have to use the 18343// same timestamp type when saving the flush timestamp. 18344// All IE versions use low-res event timestamps, and have problematic clock 18345// implementations (#9632) 18346if (inBrowser && !isIE) { 18347 var performance_1 = window.performance; 18348 if (performance_1 && 18349 typeof performance_1.now === 'function' && 18350 getNow() > document.createEvent('Event').timeStamp) { 18351 // if the event timestamp, although evaluated AFTER the Date.now(), is 18352 // smaller than it, it means the event is using a hi-res timestamp, 18353 // and we need to use the hi-res version for event listener timestamps as 18354 // well. 18355 getNow = function () { return performance_1.now(); }; 18356 } 18357} 18358var sortCompareFn = function (a, b) { 18359 if (a.post) { 18360 if (!b.post) 18361 return 1; 18362 } 18363 else if (b.post) { 18364 return -1; 18365 } 18366 return a.id - b.id; 18367}; 18368/** 18369 * Flush both queues and run the watchers. 18370 */ 18371function flushSchedulerQueue() { 18372 currentFlushTimestamp = getNow(); 18373 flushing = true; 18374 var watcher, id; 18375 // Sort queue before flush. 18376 // This ensures that: 18377 // 1. Components are updated from parent to child. (because parent is always 18378 // created before the child) 18379 // 2. A component's user watchers are run before its render watcher (because 18380 // user watchers are created before the render watcher) 18381 // 3. If a component is destroyed during a parent component's watcher run,
18382 // its watchers can be skipped. 18383 queue.sort(sortCompareFn); 18384 // do not cache length because more watchers might be pushed 18385 // as we run existing watchers 18386 for (index$1 = 0; index$1 < queue.length; index$1++) { 18387 watcher = queue[index$1]; 18388 if (watcher.before) { 18389 watcher.before(); 18390 } 18391 id = watcher.id; 18392 has[id] = null; 18393 watcher.run(); 18394 // in dev build, check and stop circular updates. 18395 if (false) {} 18396 } 18397 // keep copies of post queues before resetting state 18398 var activatedQueue = activatedChildren.slice(); 18399 var updatedQueue = queue.slice(); 18400 resetSchedulerState(); 18401 // call component updated and activated hooks 18402 callActivatedHooks(activatedQueue); 18403 callUpdatedHooks(updatedQueue); 18404 cleanupDeps(); 18405 // devtool hook 18406 /* istanbul ignore if */ 18407 if (devtools && config.devtools) { 18408 devtools.emit('flush'); 18409 } 18410} 18411function callUpdatedHooks(queue) { 18412 var i = queue.length; 18413 while (i--) { 18414 var watcher = queue[i]; 18415 var vm = watcher.vm; 18416 if (vm && vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) { 18417 callHook$1(vm, 'updated'); 18418 } 18419 } 18420} 18421/** 18422 * Queue a kept-alive component that was activated during patch. 18423 * The queue will be processed after the entire tree has been patched. 18424 */ 18425function queueActivatedComponent(vm) { 18426 // setting _inactive to false here so that a render function can 18427 // rely on checking whether it's in an inactive tree (e.g. router-view) 18428 vm._inactive = false; 18429 activatedChildren.push(vm); 18430} 18431function callActivatedHooks(queue) { 18432 for (var i = 0; i < queue.length; i++) { 18433 queue[i]._inactive = true; 18434 activateChildComponent(queue[i], true /* true */); 18435 } 18436} 18437/** 18438 * Push a watcher into the watcher queue. 18439 * Jobs with duplicate IDs will be skipped unless it's 18440 * pushed when the queue is being flushed. 18441 */ 18442function queueWatcher(watcher) { 18443 var id = watcher.id; 18444 if (has[id] != null) { 18445 return; 18446 } 18447 if (watcher === Dep.target && watcher.noRecurse) { 18448 return; 18449 } 18450 has[id] = true; 18451 if (!flushing) { 18452 queue.push(watcher); 18453 } 18454 else { 18455 // if already flushing, splice the watcher based on its id 18456 // if already past its id, it will be run next immediately. 18457 var i = queue.length - 1; 18458 while (i > index$1 && queue[i].id > watcher.id) { 18459 i--; 18460 } 18461 queue.splice(i + 1, 0, watcher); 18462 } 18463 // queue the flush 18464 if (!waiting) { 18465 waiting = true; 18466 if (false) {} 18467 nextTick(flushSchedulerQueue); 18468 } 18469} 18470 18471var WATCHER = "watcher"; 18472var WATCHER_CB = "".concat(WATCHER, " callback"); 18473var WATCHER_GETTER = "".concat(WATCHER, " getter"); 18474var WATCHER_CLEANUP = "".concat(WATCHER, " cleanup"); 18475// Simple effect. 18476function watchEffect(effect, options) { 18477 return doWatch(effect, null, options); 18478} 18479function watchPostEffect(effect, options) { 18480 return doWatch(effect, null, ( false 18481 ? 0 : { flush: 'post' })); 18482} 18483function watchSyncEffect(effect, options) { 18484 return doWatch(effect, null, ( false 18485 ? 0 : { flush: 'sync' })); 18486} 18487// initial value for watchers to trigger on undefined initial values 18488var INITIAL_WATCHER_VALUE = {}; 18489// implementation 18490function watch(source, cb, options) { 18491 if (false) {} 18492 return doWatch(source, cb, options); 18493} 18494function doWatch(source, cb, _a) { 18495 var _b = _a === void 0 ? emptyObject : _a, immediate = _b.immediate, deep = _b.deep, _c = _b.flush, flush = _c === void 0 ? 'pre' : _c, onTrack = _b.onTrack, onTrigger = _b.onTrigger; 18496 if (false) {} 18497 var warnInvalidSource = function (s) { 18498 warn$2("Invalid watch source: ".concat(s, ". A watch source can only be a getter/effect ") + 18499 "function, a ref, a reactive object, or an array of these types."); 18500 }; 18501 var instance = currentInstance; 18502 var call = function (fn, type, args) { 18503 if (args === void 0) { args = null; } 18504 var res = invokeWithErrorHandling(fn, null, args, instance, type); 18505 if (deep && res && res.__ob__) 18506 res.__ob__.dep.depend(); 18507 return res; 18508 }; 18509 var getter; 18510 var forceTrigger = false;
18511 var isMultiSource = false; 18512 if (isRef(source)) { 18513 getter = function () { return source.value; }; 18514 forceTrigger = isShallow(source); 18515 } 18516 else if (isReactive(source)) { 18517 getter = function () { 18518 source.__ob__.dep.depend(); 18519 return source; 18520 }; 18521 deep = true; 18522 } 18523 else if (isArray(source)) { 18524 isMultiSource = true; 18525 forceTrigger = source.some(function (s) { return isReactive(s) || isShallow(s); }); 18526 getter = function () { 18527 return source.map(function (s) { 18528 if (isRef(s)) { 18529 return s.value; 18530 } 18531 else if (isReactive(s)) { 18532 s.__ob__.dep.depend(); 18533 return traverse(s); 18534 } 18535 else if (isFunction(s)) { 18536 return call(s, WATCHER_GETTER); 18537 } 18538 else { 18539 false && 0; 18540 } 18541 }); 18542 }; 18543 } 18544 else if (isFunction(source)) { 18545 if (cb) { 18546 // getter with cb 18547 getter = function () { return call(source, WATCHER_GETTER); }; 18548 } 18549 else { 18550 // no cb -> simple effect 18551 getter = function () { 18552 if (instance && instance._isDestroyed) { 18553 return; 18554 } 18555 if (cleanup) { 18556 cleanup(); 18557 } 18558 return call(source, WATCHER, [onCleanup]); 18559 }; 18560 } 18561 } 18562 else { 18563 getter = noop; 18564 false && 0; 18565 } 18566 if (cb && deep) { 18567 var baseGetter_1 = getter; 18568 getter = function () { return traverse(baseGetter_1()); }; 18569 } 18570 var cleanup; 18571 var onCleanup = function (fn) { 18572 cleanup = watcher.onStop = function () { 18573 call(fn, WATCHER_CLEANUP); 18574 }; 18575 }; 18576 // in SSR there is no need to setup an actual effect, and it should be noop 18577 // unless it's eager 18578 if (isServerRendering()) { 18579 // we will also not call the invalidate callback (+ runner is not set up) 18580 onCleanup = noop; 18581 if (!cb) { 18582 getter(); 18583 } 18584 else if (immediate) { 18585 call(cb, WATCHER_CB, [ 18586 getter(), 18587 isMultiSource ? [] : undefined, 18588 onCleanup 18589 ]); 18590 } 18591 return noop; 18592 } 18593 var watcher = new Watcher(currentInstance, getter, noop, { 18594 lazy: true 18595 }); 18596 watcher.noRecurse = !cb; 18597 var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; 18598 // overwrite default run 18599 watcher.run = function () { 18600 if (!watcher.active) { 18601 return; 18602 } 18603 if (cb) { 18604 // watch(source, cb) 18605 var newValue = watcher.get(); 18606 if (deep || 18607 forceTrigger || 18608 (isMultiSource 18609 ? newValue.some(function (v, i) { 18610 return hasChanged(v, oldValue[i]); 18611 }) 18612 : hasChanged(newValue, oldValue))) { 18613 // cleanup before running cb again 18614 if (cleanup) { 18615 cleanup(); 18616 } 18617 call(cb, WATCHER_CB, [ 18618 newValue, 18619 // pass undefined as the old value when it's changed for the first time 18620 oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, 18621 onCleanup 18622 ]); 18623 oldValue = newValue; 18624 } 18625 } 18626 else { 18627 // watchEffect 18628 watcher.get(); 18629 } 18630 }; 18631 if (flush === 'sync') { 18632 watcher.update = watcher.run; 18633 } 18634 else if (flush === 'post') { 18635 watcher.post = true; 18636 watcher.update = function () { return queueWatcher(watcher); }; 18637 } 18638 else { 18639 // pre 18640 watcher.update = function () { 18641 if (instance && instance === currentInstance && !instance._isMounted) { 18642 // pre-watcher triggered before 18643 var buffer = instance._preWatchers || (instance._preWatchers = []); 18644 if (buffer.indexOf(watcher) < 0) 18645 buffer.push(watcher); 18646 } 18647 else { 18648 queueWatcher(watcher); 18649 } 18650 }; 18651 } 18652 if (false) {} 18653 // initial run 18654 if (cb) { 18655 if (immediate) { 18656 watcher.run(); 18657 } 18658 else { 18659 oldValue = watcher.get(); 18660 } 18661 } 18662 else if (flush === 'post' && instance) { 18663 instance.$once('hook:mounted', function () { return watcher.get(); }); 18664 } 18665 else { 18666 watcher.get(); 18667 } 18668 return function () { 18669 watcher.teardown(); 18670 }; 18671} 18672 18673function provide(key, value) { 18674 if (!currentInstance) { 18675 if (false) {} 18676 } 18677 else { 18678 // TS doesn't allow symbol as index type 18679 resolveProvided(currentInstance)[key] = value; 18680 } 18681} 18682function resolveProvided(vm) { 18683 // by default an instance inherits its parent's provides object 18684 // but when it needs to provide values of its own, it creates its 18685 // own provides object using parent provides object as prototype. 18686 // this way in `inject` we can simply look up injections from direct 18687 // parent and let the prototype chain do the work. 18688 var existing = vm._provided; 18689 var parentProvides = vm.$parent && vm.$parent._provided; 18690 if (parentProvides === existing) { 18691 return (vm._provided = Object.create(parentProvides)); 18692 } 18693 else { 18694 return existing; 18695 } 18696} 18697function inject(key, defaultValue, treatDefaultAsFactory) { 18698 if (treatDefaultAsFactory === void 0) { treatDefaultAsFactory = false; } 18699 // fallback to `currentRenderingInstance` so that this can be called in 18700 // a functional component 18701 var instance = currentInstance; 18702 if (instance) { 18703 // #2400 18704 // to support `app.use` plugins, 18705 // fallback to appContext's `provides` if the instance is at root 18706 var provides = instance.$parent && instance.$parent._provided; 18707 if (provides && key in provides) { 18708 // TS doesn't allow symbol as index type 18709 return provides[key]; 18710 } 18711 else if (arguments.length > 1) { 18712 return treatDefaultAsFactory && isFunction(defaultValue) 18713 ? defaultValue.call(instance) 18714 : defaultValue; 18715 } 18716 else if (false) {} 18717 } 18718 else if (false) {} 18719} 18720 18721/** 18722 * @internal this function needs manual public type declaration because it relies 18723 * on previously manually authored types from Vue 2 18724 */ 18725function h(type, props, children) { 18726 if (!currentInstance) { 18727 false && 18728 0; 18729 } 18730 return createElement$1(currentInstance, type, props, children, 2, true); 18731} 18732 18733function handleError(err, vm, info) { 18734 // Deactivate deps tracking while processing error handler to avoid possible infinite rendering. 18735 // See: https://github.com/vuejs/vuex/issues/1505 18736 pushTarget(); 18737 try { 18738 if (vm) { 18739 var cur = vm; 18740 while ((cur = cur.$parent)) { 18741 var hooks = cur.$options.errorCaptured; 18742 if (hooks) { 18743 for (var i = 0; i < hooks.length; i++) { 18744 try { 18745 var capture = hooks[i].call(cur, err, vm, info) === false; 18746 if (capture) 18747 return; 18748 } 18749 catch (e) { 18750 globalHandleError(e, cur, 'errorCaptured hook'); 18751 } 18752 } 18753 } 18754 } 18755 } 18756 globalHandleError(err, vm, info); 18757 } 18758 finally { 18759 popTarget(); 18760 } 18761} 18762function invokeWithErrorHandling(handler, context, args, vm, info) { 18763 var res; 18764 try {
18765 res = args ? handler.apply(context, args) : handler.call(context); 18766 if (res && !res._isVue && isPromise(res) && !res._handled) { 18767 res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); }); 18768 res._handled = true; 18769 } 18770 } 18771 catch (e) { 18772 handleError(e, vm, info); 18773 } 18774 return res; 18775} 18776function globalHandleError(err, vm, info) { 18777 if (config.errorHandler) { 18778 try { 18779 return config.errorHandler.call(null, err, vm, info); 18780 } 18781 catch (e) { 18782 // if the user intentionally throws the original error in the handler, 18783 // do not log it twice 18784 if (e !== err) { 18785 logError(e, null, 'config.errorHandler'); 18786 } 18787 } 18788 } 18789 logError(err, vm, info); 18790} 18791function logError(err, vm, info) { 18792 if (false) {} 18793 /* istanbul ignore else */ 18794 if (inBrowser && typeof console !== 'undefined') { 18795 console.error(err); 18796 } 18797 else { 18798 throw err; 18799 } 18800} 18801 18802/* globals MutationObserver */ 18803var isUsingMicroTask = false; 18804var callbacks = []; 18805var pending = false; 18806function flushCallbacks() { 18807 pending = false; 18808 var copies = callbacks.slice(0); 18809 callbacks.length = 0; 18810 for (var i = 0; i < copies.length; i++) { 18811 copies[i](); 18812 } 18813} 18814// Here we have async deferring wrappers using microtasks. 18815// In 2.5 we used (macro) tasks (in combination with microtasks). 18816// However, it has subtle problems when state is changed right before repaint 18817// (e.g. #6813, out-in transitions). 18818// Also, using (macro) tasks in event handler would cause some weird behaviors 18819// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109). 18820// So we now use microtasks everywhere, again. 18821// A major drawback of this tradeoff is that there are some scenarios 18822// where microtasks have too high a priority and fire in between supposedly 18823// sequential events (e.g. #4521, #6690, which have workarounds) 18824// or even between bubbling of the same event (#6566). 18825var timerFunc; 18826// The nextTick behavior leverages the microtask queue, which can be accessed 18827// via either native Promise.then or MutationObserver. 18828// MutationObserver has wider support, however it is seriously bugged in 18829// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It 18830// completely stops working after triggering a few times... so, if native 18831// Promise is available, we will use it: 18832/* istanbul ignore next, $flow-disable-line */ 18833if (typeof Promise !== 'undefined' && isNative(Promise)) { 18834 var p_1 = Promise.resolve(); 18835 timerFunc = function () { 18836 p_1.then(flushCallbacks); 18837 // In problematic UIWebViews, Promise.then doesn't completely break, but 18838 // it can get stuck in a weird state where callbacks are pushed into the 18839 // microtask queue but the queue isn't being flushed, until the browser 18840 // needs to do some other work, e.g. handle a timer. Therefore we can 18841 // "force" the microtask queue to be flushed by adding an empty timer. 18842 if (isIOS) 18843 setTimeout(noop); 18844 }; 18845 isUsingMicroTask = true; 18846} 18847else if (!isIE && 18848 typeof MutationObserver !== 'undefined' && 18849 (isNative(MutationObserver) || 18850 // PhantomJS and iOS 7.x 18851 MutationObserver.toString() === '[object MutationObserverConstructor]')) { 18852 // Use MutationObserver where native Promise is not available, 18853 // e.g. PhantomJS, iOS7, Android 4.4 18854 // (#6466 MutationObserver is unreliable in IE11) 18855 var counter_1 = 1; 18856 var observer = new MutationObserver(flushCallbacks); 18857 var textNode_1 = document.createTextNode(String(counter_1)); 18858 observer.observe(textNode_1, { 18859 characterData: true 18860 }); 18861 timerFunc = function () { 18862 counter_1 = (counter_1 + 1) % 2; 18863 textNode_1.data = String(counter_1); 18864 }; 18865 isUsingMicroTask = true; 18866} 18867else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { 18868 // Fallback to setImmediate. 18869 // Technically it leverages the (macro) task queue, 18870 // but it is still a better choice than setTimeout.
18871 timerFunc = function () { 18872 setImmediate(flushCallbacks); 18873 }; 18874} 18875else { 18876 // Fallback to setTimeout. 18877 timerFunc = function () { 18878 setTimeout(flushCallbacks, 0); 18879 }; 18880} 18881/** 18882 * @internal 18883 */ 18884function nextTick(cb, ctx) { 18885 var _resolve; 18886 callbacks.push(function () { 18887 if (cb) { 18888 try { 18889 cb.call(ctx); 18890 } 18891 catch (e) { 18892 handleError(e, ctx, 'nextTick'); 18893 } 18894 } 18895 else if (_resolve) { 18896 _resolve(ctx); 18897 } 18898 }); 18899 if (!pending) { 18900 pending = true; 18901 timerFunc(); 18902 } 18903 // $flow-disable-line 18904 if (!cb && typeof Promise !== 'undefined') { 18905 return new Promise(function (resolve) { 18906 _resolve = resolve; 18907 }); 18908 } 18909} 18910 18911function useCssModule(name) { 18912 if (name === void 0) { name = '$style'; } 18913 /* istanbul ignore else */ 18914 { 18915 if (!currentInstance) { 18916 false && 0; 18917 return emptyObject; 18918 } 18919 var mod = currentInstance[name]; 18920 if (!mod) { 18921 false && 18922 0; 18923 return emptyObject; 18924 } 18925 return mod; 18926 } 18927} 18928 18929/** 18930 * Runtime helper for SFC's CSS variable injection feature. 18931 * @private 18932 */ 18933function useCssVars(getter) { 18934 if (!inBrowser && !false) 18935 return; 18936 var instance = currentInstance; 18937 if (!instance) { 18938 false && 18939 0; 18940 return; 18941 } 18942 watchPostEffect(function () { 18943 var el = instance.$el; 18944 var vars = getter(instance, instance._setupProxy); 18945 if (el && el.nodeType === 1) { 18946 var style = el.style; 18947 for (var key in vars) { 18948 style.setProperty("--".concat(key), vars[key]); 18949 } 18950 } 18951 }); 18952} 18953 18954/** 18955 * v3-compatible async component API. 18956 * @internal the type is manually declared in <root>/types/v3-define-async-component.d.ts 18957 * because it relies on existing manual types 18958 */ 18959function defineAsyncComponent(source) { 18960 if (isFunction(source)) { 18961 source = { loader: source }; 18962 } 18963 var loader = source.loader, loadingComponent = source.loadingComponent, errorComponent = source.errorComponent, _a = source.delay, delay = _a === void 0 ? 200 : _a, timeout = source.timeout, // undefined = never times out 18964 _b = source.suspensible, // undefined = never times out 18965 suspensible = _b === void 0 ? false : _b, // in Vue 3 default is true 18966 userOnError = source.onError; 18967 if (false) {} 18968 var pendingRequest = null; 18969 var retries = 0; 18970 var retry = function () { 18971 retries++; 18972 pendingRequest = null; 18973 return load(); 18974 }; 18975 var load = function () { 18976 var thisRequest; 18977 return (pendingRequest || 18978 (thisRequest = pendingRequest = 18979 loader() 18980 .catch(function (err) { 18981 err = err instanceof Error ? err : new Error(String(err)); 18982 if (userOnError) { 18983 return new Promise(function (resolve, reject) { 18984 var userRetry = function () { return resolve(retry()); }; 18985 var userFail = function () { return reject(err); }; 18986 userOnError(err, userRetry, userFail, retries + 1); 18987 }); 18988 } 18989 else { 18990 throw err; 18991 } 18992 }) 18993 .then(function (comp) { 18994 if (thisRequest !== pendingRequest && pendingRequest) { 18995 return pendingRequest; 18996 } 18997 if (false) {} 18998 // interop module default 18999 if (comp && 19000 (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { 19001 comp = comp.default; 19002 } 19003 if (false) {} 19004 return comp; 19005 }))); 19006 }; 19007 return function () { 19008 var component = load(); 19009 return { 19010 component: component, 19011 delay: delay, 19012 timeout: timeout, 19013 error: errorComponent, 19014 loading: loadingComponent 19015 }; 19016 }; 19017} 19018 19019function createLifeCycle(hookName) { 19020 return function (fn, target) { 19021 if (target === void 0) { target = currentInstance; } 19022 if (!target) { 19023 false && 19024 0; 19025 return; 19026 } 19027 return injectHook(target, hookName, fn); 19028 }; 19029} 19030function formatName(name) { 19031 if (name === 'beforeDestroy') { 19032 name = 'beforeUnmount'; 19033 } 19034 else if (name === 'destroyed') { 19035 name = 'unmounted'; 19036 } 19037 return "on".concat(name[0].toUpperCase() + name.slice(1)); 19038} 19039function injectHook(instance, hookName, fn) { 19040 var options = instance.$options; 19041 options[hookName] = mergeLifecycleHook(options[hookName], fn); 19042} 19043var onBeforeMount = createLifeCycle('beforeMount'); 19044var onMounted = createLifeCycle('mounted'); 19045var onBeforeUpdate = createLifeCycle('beforeUpdate');
19046var onUpdated = createLifeCycle('updated'); 19047var onBeforeUnmount = createLifeCycle('beforeDestroy'); 19048var onUnmounted = createLifeCycle('destroyed'); 19049var onActivated = createLifeCycle('activated'); 19050var onDeactivated = createLifeCycle('deactivated'); 19051var onServerPrefetch = createLifeCycle('serverPrefetch'); 19052var onRenderTracked = createLifeCycle('renderTracked'); 19053var onRenderTriggered = createLifeCycle('renderTriggered'); 19054var injectErrorCapturedHook = createLifeCycle('errorCaptured'); 19055function onErrorCaptured(hook, target) { 19056 if (target === void 0) { target = currentInstance; } 19057 injectErrorCapturedHook(hook, target); 19058} 19059 19060/** 19061 * Note: also update dist/vue.runtime.mjs when adding new exports to this file. 19062 */ 19063var version = '2.7.16'; 19064/** 19065 * @internal type is manually declared in <root>/types/v3-define-component.d.ts 19066 */ 19067function defineComponent(options) { 19068 return options; 19069} 19070 19071var seenObjects = new _Set(); 19072/** 19073 * Recursively traverse an object to evoke all converted 19074 * getters, so that every nested property inside the object 19075 * is collected as a "deep" dependency. 19076 */ 19077function traverse(val) { 19078 _traverse(val, seenObjects); 19079 seenObjects.clear(); 19080 return val; 19081} 19082function _traverse(val, seen) { 19083 var i, keys; 19084 var isA = isArray(val); 19085 if ((!isA && !isObject(val)) || 19086 val.__v_skip /* ReactiveFlags.SKIP */ || 19087 Object.isFrozen(val) || 19088 val instanceof VNode) { 19089 return; 19090 } 19091 if (val.__ob__) { 19092 var depId = val.__ob__.dep.id; 19093 if (seen.has(depId)) { 19094 return; 19095 } 19096 seen.add(depId); 19097 } 19098 if (isA) { 19099 i = val.length; 19100 while (i--) 19101 _traverse(val[i], seen); 19102 } 19103 else if (isRef(val)) { 19104 _traverse(val.value, seen); 19105 } 19106 else { 19107 keys = Object.keys(val); 19108 i = keys.length; 19109 while (i--) 19110 _traverse(val[keys[i]], seen); 19111 } 19112} 19113 19114var uid$1 = 0; 19115/** 19116 * A watcher parses an expression, collects dependencies, 19117 * and fires callback when the expression value changes. 19118 * This is used for both the $watch() api and directives. 19119 * @internal 19120 */ 19121var Watcher = /** @class */ (function () { 19122 function Watcher(vm, expOrFn, cb, options, isRenderWatcher) { 19123 recordEffectScope(this, 19124 // if the active effect scope is manually created (not a component scope), 19125 // prioritize it 19126 activeEffectScope && !activeEffectScope._vm 19127 ? activeEffectScope 19128 : vm 19129 ? vm._scope 19130 : undefined); 19131 if ((this.vm = vm) && isRenderWatcher) { 19132 vm._watcher = this; 19133 } 19134 // options 19135 if (options) { 19136 this.deep = !!options.deep; 19137 this.user = !!options.user; 19138 this.lazy = !!options.lazy; 19139 this.sync = !!options.sync; 19140 this.before = options.before; 19141 if (false) {} 19142 } 19143 else { 19144 this.deep = this.user = this.lazy = this.sync = false; 19145 } 19146 this.cb = cb; 19147 this.id = ++uid$1; // uid for batching 19148 this.active = true; 19149 this.post = false; 19150 this.dirty = this.lazy; // for lazy watchers 19151 this.deps = []; 19152 this.newDeps = []; 19153 this.depIds = new _Set(); 19154 this.newDepIds = new _Set(); 19155 this.expression = false ? 0 : ''; 19156 // parse expression for getter 19157 if (isFunction(expOrFn)) { 19158 this.getter = expOrFn; 19159 } 19160 else { 19161 this.getter = parsePath(expOrFn); 19162 if (!this.getter) { 19163 this.getter = noop; 19164 false && 19165 0; 19166 } 19167 } 19168 this.value = this.lazy ? undefined : this.get(); 19169 } 19170 /** 19171 * Evaluate the getter, and re-collect dependencies. 19172 */ 19173 Watcher.prototype.get = function () { 19174 pushTarget(this); 19175 var value; 19176 var vm = this.vm; 19177 try { 19178 value = this.getter.call(vm, vm); 19179 } 19180 catch (e) { 19181 if (this.user) { 19182 handleError(e, vm, "getter for watcher \"".concat(this.expression, "\"")); 19183 } 19184 else { 19185 throw e; 19186 } 19187 } 19188 finally { 19189 // "touch" every property so they are all tracked as 19190 // dependencies for deep watching 19191 if (this.deep) { 19192 traverse(value); 19193 } 19194 popTarget(); 19195 this.cleanupDeps(); 19196 } 19197 return value; 19198 }; 19199 /** 19200 * Add a dependency to this directive. 19201 */ 19202 Watcher.prototype.addDep = function (dep) { 19203 var id = dep.id; 19204 if (!this.newDepIds.has(id)) { 19205 this.newDepIds.add(id); 19206 this.newDeps.push(dep); 19207 if (!this.depIds.has(id)) { 19208 dep.addSub(this); 19209 } 19210 } 19211 }; 19212 /** 19213 * Clean up for dependency collection. 19214 */ 19215 Watcher.prototype.cleanupDeps = function () { 19216 var i = this.deps.length; 19217 while (i--) { 19218 var dep = this.deps[i]; 19219 if (!this.newDepIds.has(dep.id)) { 19220 dep.removeSub(this); 19221 } 19222 } 19223 var tmp = this.depIds; 19224 this.depIds = this.newDepIds; 19225 this.newDepIds = tmp; 19226 this.newDepIds.clear(); 19227 tmp = this.deps; 19228 this.deps = this.newDeps; 19229 this.newDeps = tmp; 19230 this.newDeps.length = 0; 19231 }; 19232 /** 19233 * Subscriber interface. 19234 * Will be called when a dependency changes. 19235 */ 19236 Watcher.prototype.update = function () { 19237 /* istanbul ignore else */ 19238 if (this.lazy) { 19239 this.dirty = true; 19240 } 19241 else if (this.sync) { 19242 this.run(); 19243 } 19244 else { 19245 queueWatcher(this); 19246 } 19247 }; 19248 /** 19249 * Scheduler job interface. 19250 * Will be called by the scheduler. 19251 */ 19252 Watcher.prototype.run = function () { 19253 if (this.active) { 19254 var value = this.get(); 19255 if (value !== this.value ||
19256 // Deep watchers and watchers on Object/Arrays should fire even 19257 // when the value is the same, because the value may 19258 // have mutated. 19259 isObject(value) || 19260 this.deep) { 19261 // set new value 19262 var oldValue = this.value; 19263 this.value = value; 19264 if (this.user) { 19265 var info = "callback for watcher \"".concat(this.expression, "\""); 19266 invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info); 19267 } 19268 else { 19269 this.cb.call(this.vm, value, oldValue); 19270 } 19271 } 19272 } 19273 }; 19274 /** 19275 * Evaluate the value of the watcher. 19276 * This only gets called for lazy watchers. 19277 */ 19278 Watcher.prototype.evaluate = function () { 19279 this.value = this.get(); 19280 this.dirty = false; 19281 }; 19282 /** 19283 * Depend on all deps collected by this watcher. 19284 */ 19285 Watcher.prototype.depen
19285d = function () { 19286 var i = this.deps.length; 19287 while (i--) { 19288 this.deps[i].depend(); 19289 } 19290 }; 19291 /** 19292 * Remove self from all dependencies' subscriber list. 19293 */ 19294 Watcher.prototype.teardown = function () { 19295 if (this.vm && !this.vm._isBeingDestroyed) { 19296 remove$2(this.vm._scope.effects, this); 19297 } 19298 if (this.active) { 19299 var i = this.deps.length; 19300 while (i--) { 19301 this.deps[i].removeSub(this); 19302 } 19303 this.active = false; 19304 if (this.onStop) { 19305 this.onStop(); 19306 } 19307 } 19308 }; 19309 return Watcher; 19310}()); 19311 19312var sharedPropertyDefinition = { 19313 enumerable: true, 19314 configurable: true, 19315 get: noop, 19316 set: noop 19317}; 19318function proxy(target, sourceKey, key) { 19319 sharedPropertyDefinition.get = function proxyGetter() { 19320 return this[sourceKey][key]; 19321 }; 19322 sharedPropertyDefinition.set = function proxySetter(val) { 19323 this[sourceKey][key] = val; 19324 }; 19325 Object.defineProperty(target, key, sharedPropertyDefinition); 19326} 19327function initState(vm) { 19328 var opts = vm.$options; 19329 if (opts.props) 19330 initProps$1(vm, opts.props); 19331 // Composition API 19332 initSetup(vm); 19333 if (opts.methods) 19334 initMethods(vm, opts.methods); 19335 if (opts.data) { 19336 initData(vm); 19337 } 19338 else { 19339 var ob = observe((vm._data = {})); 19340 ob && ob.vmCount++; 19341 } 19342 if (opts.computed) 19343 initComputed$1(vm, opts.computed); 19344 if (opts.watch && opts.watch !== nativeWatch) { 19345 initWatch(vm, opts.watch); 19346 } 19347} 19348function initProps$1(vm, propsOptions) { 19349 var propsData = vm.$options.propsData || {}; 19350 var props = (vm._props = shallowReactive({})); 19351 // cache prop keys so that future props updates can iterate using Array 19352 // instead of dynamic object key enumeration. 19353 var keys = (vm.$options._propKeys = []); 19354 var isRoot = !vm.$parent; 19355 // root instance props should be converted 19356 if (!isRoot) { 19357 toggleObserving(false); 19358 } 19359 var _loop_1 = function (key) { 19360 keys.push(key); 19361 var value = validateProp(key, propsOptions, propsData, vm); 19362 /* istanbul ignore else */ 19363 if (false) { var hyphenatedKey; } 19364 else { 19365 defineReactive(props, key, value, undefined, true /* shallow */); 19366 } 19367 // static props are already proxied on the component's prototype 19368 // during Vue.extend(). We only need to proxy props defined at 19369 // instantiation here. 19370 if (!(key in vm)) { 19371 proxy(vm, "_props", key); 19372 } 19373 }; 19374 for (var key in propsOptions) { 19375 _loop_1(key); 19376 } 19377 toggleObserving(true); 19378} 19379function initData(vm) { 19380 var data = vm.$options.data; 19381 data = vm._data = isFunction(data) ? getData(data, vm) : data || {}; 19382 if (!isPlainObject(data)) { 19383 data = {}; 19384 false && 19385 0; 19386 } 19387 // proxy data on instance 19388 var keys = Object.keys(data); 19389 var props = vm.$options.props; 19390 var methods = vm.$options.methods; 19391 var i = keys.length; 19392 while (i--) { 19393 var key = keys[i]; 19394 if (false) {} 19395 if (props && hasOwn(props, key)) { 19396 false && 19397 0; 19398 } 19399 else if (!isReserved(key)) { 19400 proxy(vm, "_data", key); 19401 } 19402 } 19403 // observe data 19404 var ob = observe(data); 19405 ob && ob.vmCount++; 19406} 19407function getData(data, vm) { 19408 // #7573 disable dep collection when invoking data getters 19409 pushTarget(); 19410 try { 19411 return data.call(vm, vm); 19412 } 19413 catch (e) { 19414 handleError(e, vm, "data()"); 19415 return {}; 19416 } 19417 finally { 19418 popTarget(); 19419 } 19420} 19421var computedWatcherOptions = { lazy: true }; 19422function initComputed$1(vm, computed) { 19423 // $flow-disable-line 19424 var watchers = (vm._computedWatchers = Object.create(null)); 19425 // computed properties are just getters during SSR 19426 var isSSR = isServerRendering(); 19427 for (var key in computed) { 19428 var userDef = computed[key]; 19429 var getter = isFunction(userDef) ? userDef : userDef.get; 19430 if (false) {} 19431 if (!isSSR) { 19432 // create internal watcher for the computed property. 19433 watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions); 19434 } 19435 // component-defined computed properties are already defined on the 19436 // component prototype. We only need to define computed properties defined 19437 // at instantiation here. 19438 if (!(key in vm)) { 19439 defineComputed(vm, key, userDef); 19440 } 19441 else if (false) {} 19442 } 19443} 19444function defineComputed(target, key, userDef) { 19445 var shouldCache = !isServerRendering(); 19446 if (isFunction(userDef)) { 19447 sharedPropertyDefinition.get = shouldCache 19448 ? createComputedGetter(key) 19449 : createGetterInvoker(userDef); 19450 sharedPropertyDefinition.set = noop; 19451 } 19452 else { 19453 sharedPropertyDefinition.get = userDef.get 19454 ? shouldCache && userDef.cache !== false 19455 ? createComputedGetter(key) 19456 : createGetterInvoker(userDef.get) 19457 : noop; 19458 sharedPropertyDefinition.set = userDef.set || noop; 19459 } 19460 if (false) {} 19461 Object.defineProperty(target, key, sharedPropertyDefinition); 19462} 19463function createComputedGetter(key) { 19464 return function computedGetter() { 19465 var watcher = this._computedWatchers && this._computedWatchers[key]; 19466 if (watcher) { 19467 if (watcher.dirty) { 19468 watcher.evaluate(); 19469 } 19470 if (Dep.target) { 19471 if (false) {}
19472 watcher.depend(); 19473 } 19474 return watcher.value; 19475 } 19476 }; 19477} 19478function createGetterInvoker(fn) { 19479 return function computedGetter() { 19480 return fn.call(this, this); 19481 }; 19482} 19483function initMethods(vm, methods) { 19484 var props = vm.$options.props; 19485 for (var key in methods) { 19486 if (false) {} 19487 vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm); 19488 } 19489} 19490function initWatch(vm, watch) { 19491 for (var key in watch) { 19492 var handler = watch[key]; 19493 if (isArray(handler)) { 19494 for (var i = 0; i < handler.length; i++) { 19495 createWatcher(vm, key, handler[i]); 19496 } 19497 } 19498 else { 19499 createWatcher(vm, key, handler); 19500 } 19501 } 19502} 19503function createWatcher(vm, expOrFn, handler, options) { 19504 if (isPlainObject(handler)) { 19505 options = handler; 19506 handler = handler.handler; 19507 } 19508 if (typeof handler === 'string') { 19509 handler = vm[handler]; 19510 } 19511 return vm.$watch(expOrFn, handler, options); 19512} 19513function stateMixin(Vue) { 19514 // flow somehow has problems with directly declared definition object 19515 // when using Object.defineProperty, so we have to procedurally build up 19516 // the object here. 19517 var dataDef = {}; 19518 dataDef.get = function () { 19519 return this._data; 19520 }; 19521 var propsDef = {}; 19522 propsDef.get = function () { 19523 return this._props; 19524 }; 19525 if (false) {} 19526 Object.defineProperty(Vue.prototype, '$data', dataDef); 19527 Object.defineProperty(Vue.prototype, '$props', propsDef); 19528 Vue.prototype.$set = set; 19529 Vue.prototype.$delete = del; 19530 Vue.prototype.$watch = function (expOrFn, cb, options) { 19531 var vm = this; 19532 if (isPlainObject(cb)) { 19533 return createWatcher(vm, expOrFn, cb, options); 19534 } 19535 options = options || {}; 19536 options.user = true; 19537 var watcher = new Watcher(vm, expOrFn, cb, options); 19538 if (options.immediate) { 19539 var info = "callback for immediate watcher \"".concat(watcher.expression, "\""); 19540 pushTarget(); 19541 invokeWithErrorHandling(cb, vm, [watcher.value], vm, info); 19542 popTarget(); 19543 } 19544 return function unwatchFn() { 19545 watcher.teardown(); 19546 }; 19547 }; 19548} 19549 19550function initProvide(vm) { 19551 var provideOption = vm.$options.provide; 19552 if (provideOption) { 19553 var provided = isFunction(provideOption) 19554 ? provideOption.call(vm) 19555 : provideOption; 19556 if (!isObject(provided)) { 19557 return; 19558 } 19559 var source = resolveProvided(vm); 19560 // IE9 doesn't support Object.getOwnPropertyDescriptors so we have to 19561 // iterate the keys ourselves. 19562 var keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided); 19563 for (var i = 0; i < keys.length; i++) { 19564 var key = keys[i]; 19565 Object.defineProperty(source, key, Object.getOwnPropertyDescriptor(provided, key)); 19566 } 19567 } 19568} 19569function initInjections(vm) { 19570 var result = resolveInject(vm.$options.inject, vm); 19571 if (result) { 19572 toggleObserving(false); 19573 Object.keys(result).forEach(function (key) { 19574 /* istanbul ignore else */ 19575 if (false) {} 19576 else { 19577 defineReactive(vm, key, result[key]); 19578 } 19579 }); 19580 toggleObserving(true); 19581 } 19582} 19583function resolveInject(inject, vm) { 19584 if (inject) { 19585 // inject is :any because flow is not smart enough to figure out cached 19586 var result = Object.create(null); 19587 var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject); 19588 for (var i = 0; i < keys.length; i++) { 19589 var key = keys[i]; 19590 // #6574 in case the inject object is observed... 19591 if (key === '__ob__') 19592 continue; 19593 var provideKey = inject[key].from; 19594 if (provideKey in vm._provided) { 19595 result[key] = vm._provided[provideKey]; 19596 } 19597 else if ('default' in inject[key]) { 19598 var provideDefault = inject[key].default; 19599 result[key] = isFunction(provideDefault) 19600 ? provideDefault.call(vm) 19601 : provideDefault; 19602 } 19603 else if (false) {} 19604 } 19605 return result; 19606 } 19607} 19608 19609var uid = 0; 19610function initMixin$1(Vue) { 19611 Vue.prototype._init = function (options) { 19612 var vm = this; 19613 // a uid 19614 vm._uid = uid++; 19615 var startTag, endTag; 19616 /* istanbul ignore if */ 19617 if (false) {} 19618 // a flag to mark this as a Vue instance without having to do instanceof 19619 // check 19620 vm._isVue = true; 19621 // avoid instances from being observed 19622 vm.__v_skip = true; 19623 // effect scope 19624 vm._scope = new EffectScope(true /* detached */); 19625 // #13134 edge case where a child component is manually created during the 19626 // render of a parent component 19627 vm._scope.parent = undefined; 19628 vm._scope._vm = true; 19629 // merge options 19630 if (options && options._isComponent) {
19631 // optimize internal component instantiation 19632 // since dynamic options merging is pretty slow, and none of the 19633 // internal component options needs special treatment. 19634 initInternalComponent(vm, options); 19635 } 19636 else { 19637 vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm); 19638 } 19639 /* istanbul ignore else */ 19640 if (false) {} 19641 else { 19642 vm._renderProxy = vm; 19643 } 19644 // expose real self 19645 vm._self = vm; 19646 initLifecycle(vm); 19647 initEvents(vm); 19648 initRender(vm); 19649 callHook$1(vm, 'beforeCreate', undefined, false /* setContext */); 19650 initInjections(vm); // resolve injections before data/props 19651 initState(vm); 19652 initProvide(vm); // resolve provide after data/props 19653 callHook$1(vm, 'created'); 19654 /* istanbul ignore if */ 19655 if (false) {} 19656 if (vm.$options.el) { 19657 vm.$mount(vm.$options.el); 19658 } 19659 }; 19660} 19661function initInternalComponent(vm, options) { 19662 var opts = (vm.$options = Object.create(vm.constructor.options)); 19663 // doing this because it's faster than dynamic enumeration. 19664 var parentVnode = options._parentVnode; 19665 opts.parent = options.parent; 19666 opts._parentVnode = parentVnode; 19667 var vnodeComponentOptions = parentVnode.componentOptions; 19668 opts.propsData = vnodeComponentOptions.propsData; 19669 opts._parentListeners = vnodeComponentOptions.listeners; 19670 opts._renderChildren = vnodeComponentOptions.children; 19671 opts._componentTag = vnodeComponentOptions.tag; 19672 if (options.render) { 19673 opts.render = options.render; 19674 opts.staticRenderFns = options.staticRenderFns; 19675 } 19676} 19677function resolveConstructorOptions(Ctor) { 19678 var options = Ctor.options; 19679 if (Ctor.super) { 19680 var superOptions = resolveConstructorOptions(Ctor.super); 19681 var cachedSuperOptions = Ctor.superOptions; 19682 if (superOptions !== cachedSuperOptions) { 19683 // super option changed, 19684 // need to resolve new options. 19685 Ctor.superOptions = superOptions; 19686 // check if there are any late-modified/attached options (#4976) 19687 var modifiedOptions = resolveModifiedOptions(Ctor); 19688 // update base extend options 19689 if (modifiedOptions) { 19690 extend(Ctor.extendOptions, modifiedOptions); 19691 } 19692 options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); 19693 if (options.name) { 19694 options.components[options.name] = Ctor; 19695 } 19696 } 19697 } 19698 return options; 19699} 19700function resolveModifiedOptions(Ctor) { 19701 var modified; 19702 var latest = Ctor.options; 19703 var sealed = Ctor.sealedOptions; 19704 for (var key in latest) { 19705 if (latest[key] !== sealed[key]) { 19706 if (!modified) 19707 modified = {}; 19708 modified[key] = latest[key]; 19709 } 19710 } 19711 return modified; 19712} 19713 19714function FunctionalRenderContext(data, props, children, parent, Ctor) { 19715 var _this = this; 19716 var options = Ctor.options; 19717 // ensure the createElement function in functional components 19718 // gets a unique context - this is necessary for correct named slot check 19719 var contextVm; 19720 if (hasOwn(parent, '_uid')) { 19721 contextVm = Object.create(parent); 19722 contextVm._original = parent; 19723 } 19724 else { 19725 // the context vm passed in is a functional context as well. 19726 // in this case we want to make sure we are able to get a hold to the 19727 // real context instance. 19728 contextVm = parent; 19729 // @ts-ignore 19730 parent = parent._original; 19731 } 19732 var isCompiled = isTrue(options._compiled); 19733 var needNormalization = !isCompiled; 19734 this.data = data; 19735 this.props = props; 19736 this.children = children; 19737 this.parent = parent; 19738 this.listeners = data.on || emptyObject; 19739 this.injections = resolveInject(options.inject, parent); 19740 this.slots = function () { 19741 if (!_this.$slots) { 19742 normalizeScopedSlots(parent, data.scopedSlots, (_this.$slots = resolveSlots(children, parent))); 19743 } 19744 return _this.$slots; 19745 };
19746 Object.defineProperty(this, 'scopedSlots', { 19747 enumerable: true, 19748 get: function () { 19749 return normalizeScopedSlots(parent, data.scopedSlots, this.slots()); 19750 } 19751 }); 19752 // support for compiled functional template 19753 if (isCompiled) { 19754 // exposing $options for renderStatic() 19755 this.$options = options; 19756 // pre-resolve slots for renderSlot() 19757 this.$slots = this.slots(); 19758 this.$scopedSlots = normalizeScopedSlots(parent, data.scopedSlots, this.$slots); 19759 } 19760 if (options._scopeId) { 19761 this._c = function (a, b, c, d) { 19762 var vnode = createElement$1(contextVm, a, b, c, d, needNormalization); 19763 if (vnode && !isArray(vnode)) { 19764 vnode.fnScopeId = options._scopeId; 19765 vnode.fnContext = parent; 19766 } 19767 return vnode; 19768 }; 19769 } 19770 else { 19771 this._c = function (a, b, c, d) { 19772 return createElement$1(contextVm, a, b, c, d, needNormalization); 19773 }; 19774 } 19775} 19776installRenderHelpers(FunctionalRenderContext.prototype); 19777function createFunctionalComponent(Ctor, propsData, data, contextVm, children) { 19778 var options = Ctor.options; 19779 var props = {}; 19780 var propOptions = options.props; 19781 if (isDef(propOptions)) { 19782 for (var key in propOptions) { 19783 props[key] = validateProp(key, propOptions, propsData || emptyObject); 19784 } 19785 } 19786 else { 19787 if (isDef(data.attrs)) 19788 mergeProps(props, data.attrs); 19789 if (isDef(data.props)) 19790 mergeProps(props, data.props); 19791 } 19792 var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor); 19793 var vnode = options.render.call(null, renderContext._c, renderContext); 19794 if (vnode instanceof VNode) { 19795 return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext); 19796 } 19797 else if (isArray(vnode)) { 19798 var vnodes = normalizeChildren(vnode) || []; 19799 var res = new Array(vnodes.length); 19800 for (var i = 0; i < vnodes.length; i++) { 19801 res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext); 19802 } 19803 return res; 19804 } 19805} 19806function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) { 19807 // #7817 clone node before setting fnContext, otherwise if the node is reused 19808 // (e.g. it was from a cached normal slot) the fnContext causes named slots 19809 // that should not be matched to match. 19810 var clone = cloneVNode(vnode); 19811 clone.fnContext = contextVm; 19812 clone.fnOptions = options; 19813 if (false) {} 19814 if (data.slot) { 19815 (clone.data || (clone.data = {})).slot = data.slot; 19816 } 19817 return clone; 19818} 19819function mergeProps(to, from) { 19820 for (var key in from) { 19821 to[camelize(key)] = from[key]; 19822 } 19823} 19824 19825function getComponentName(options) { 19826 return options.name || options.__name || options._componentTag; 19827} 19828// inline hooks to be invoked on component VNodes during patch
19829var componentVNodeHooks = { 19830 init: function (vnode, hydrating) { 19831 if (vnode.componentInstance && 19832 !vnode.componentInstance._isDestroyed && 19833 vnode.data.keepAlive) { 19834 // kept-alive components, treat as a patch 19835 var mountedNode = vnode; // work around flow 19836 componentVNodeHooks.prepatch(mountedNode, mountedNode); 19837 } 19838 else { 19839 var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance)); 19840 child.$mount(hydrating ? vnode.elm : undefined, hydrating); 19841 } 19842 }, 19843 prepatch: function (oldVnode, vnode) { 19844 var options = vnode.componentOptions; 19845 var child = (vnode.componentInstance = oldVnode.componentInstance); 19846 updateChildComponent(child, options.propsData, // updated props 19847 options.listeners, // updated listeners 19848 vnode, // new parent vnode 19849 options.children // new children 19850 ); 19851 }, 19852 insert: function (vnode) { 19853 var context = vnode.context, componentInstance = vnode.componentInstance; 19854 if (!componentInstance._isMounted) { 19855 componentInstance._isMounted = true; 19856 callHook$1(componentInstance, 'mounted'); 19857 } 19858 if (vnode.data.keepAlive) { 19859 if (context._isMounted) { 19860 // vue-router#1212 19861 // During updates, a kept-alive component's child components may 19862 // change, so directly walking the tree here may call activated hooks 19863 // on incorrect children. Instead we push them into a queue which will 19864 // be processed after the whole patch process ended. 19865 queueActivatedComponent(componentInstance); 19866 } 19867 else { 19868 activateChildComponent(componentInstance, true /* direct */); 19869 } 19870 } 19871 }, 19872 destroy: function (vnode) { 19873 var componentInstance = vnode.componentInstance; 19874 if (!componentInstance._isDestroyed) { 19875 if (!vnode.data.keepAlive) { 19876 componentInstance.$destroy(); 19877 } 19878 else { 19879 deactivateChildComponent(componentInstance, true /* direct */); 19880 } 19881 } 19882 } 19883}; 19884var hooksToMerge = Object.keys(componentVNodeHooks); 19885function createComponent(Ctor, data, context, children, tag) { 19886 if (isUndef(Ctor)) { 19887 return; 19888 } 19889 var baseCtor = context.$options._base; 19890 // plain options object: turn it into a constructor 19891 if (isObject(Ctor)) { 19892 Ctor = baseCtor.extend(Ctor); 19893 } 19894 // if at this stage it's not a constructor or an async component factory, 19895 // reject. 19896 if (typeof Ctor !== 'function') { 19897 if (false) {} 19898 return; 19899 } 19900 // async component 19901 var asyncFactory; 19902 // @ts-expect-error 19903 if (isUndef(Ctor.cid)) { 19904 asyncFactory = Ctor; 19905 Ctor = resolveAsyncComponent(asyncFactory, baseCtor); 19906 if (Ctor === undefined) { 19907 // return a placeholder node for async component, which is rendered 19908 // as a comment node but preserves all the raw information for the node. 19909 // the information will be used for async server-rendering and hydration. 19910 return createAsyncPlaceholder(asyncFactory, data, context, children, tag); 19911 } 19912 } 19913 data = data || {}; 19914 // resolve constructor options in case global mixins are applied after 19915 // component constructor creation 19916 resolveConstructorOptions(Ctor); 19917 // transform component v-model data into props & events 19918 if (isDef(data.model)) { 19919 // @ts-expect-error 19920 transformModel(Ctor.options, data); 19921 } 19922 // extract props 19923 // @ts-expect-error 19924 var propsData = extractPropsFromVNodeData(data, Ctor, tag); 19925 // functional component 19926 // @ts-expect-error 19927 if (isTrue(Ctor.options.functional)) { 19928 return createFunctionalComponent(Ctor, propsData, data, context, children); 19929 } 19930 // extract listeners, since these needs to be treated as 19931 // child component listeners instead of DOM listeners 19932 var listeners = data.on; 19933 // replace with listeners with .native modifier 19934 // so it gets processed during parent component patch. 19935 data.on = data.nativeOn; 19936 // @ts-expect-error 19937 if (isTrue(Ctor.options.abstract)) { 19938 // abstract components do not keep anything 19939 // other than props & listeners & slot 19940 // work around flow 19941 var slot = data.slot; 19942 data = {}; 19943 if (slot) { 19944 data.slot = slot; 19945 } 19946 }
19947 // install component management hooks onto the placeholder node 19948 installComponentHooks(data); 19949 // return a placeholder vnode 19950 // @ts-expect-error 19951 var name = getComponentName(Ctor.options) || tag; 19952 var vnode = new VNode( 19953 // @ts-expect-error 19954 "vue-component-".concat(Ctor.cid).concat(name ? "-".concat(name) : ''), data, undefined, undefined, undefined, context, 19955 // @ts-expect-error 19956 { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory); 19957 return vnode; 19958} 19959function createComponentInstanceForVnode( 19960// we know it's MountedComponentVNode but flow doesn't 19961vnode, 19962// activeInstance in lifecycle state 19963parent) { 19964 var options = { 19965 _isComponent: true, 19966 _parentVnode: vnode, 19967 parent: parent 19968 }; 19969 // check inline-template render functions 19970 var inlineTemplate = vnode.data.inlineTemplate; 19971 if (isDef(inlineTemplate)) { 19972 options.render = inlineTemplate.render; 19973 options.staticRenderFns = inlineTemplate.staticRenderFns; 19974 } 19975 return new vnode.componentOptions.Ctor(options); 19976} 19977function installComponentHooks(data) { 19978 var hooks = data.hook || (data.hook = {}); 19979 for (var i = 0; i < hooksToMerge.length; i++) { 19980 var key = hooksToMerge[i]; 19981 var existing = hooks[key]; 19982 var toMerge = componentVNodeHooks[key]; 19983 // @ts-expect-error 19984 if (existing !== toMerge && !(existing && existing._merged)) { 19985 hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge; 19986 } 19987 } 19988} 19989function mergeHook(f1, f2) { 19990 var merged = function (a, b) { 19991 // flow complains about extra args which is why we use any 19992 f1(a, b); 19993 f2(a, b); 19994 }; 19995 merged._merged = true; 19996 return merged; 19997} 19998// transform component v-model info (value and callback) into 19999// prop and event handler respectively. 20000function transformModel(options, data) { 20001 var prop = (options.model && options.model.prop) || 'value'; 20002 var event = (options.model && options.model.event) || 'input'; 20003 (data.attrs || (data.attrs = {}))[prop] = data.model.value; 20004 var on = data.on || (data.on = {}); 20005 var existing = on[event]; 20006 var callback = data.model.callback; 20007 if (isDef(existing)) { 20008 if (isArray(existing) 20009 ? existing.indexOf(callback) === -1 20010 : existing !== callback) { 20011 on[event] = [callback].concat(existing); 20012 } 20013 } 20014 else { 20015 on[event] = callback; 20016 } 20017} 20018 20019var warn$2 = noop; 20020var tip = (/* unused pure expression or super */ null && (noop)); 20021var generateComponentTrace; // work around flow check 20022var formatComponentName; 20023if (false) { var repeat_1, classify_1, classifyRE_1, hasConsole_1; } 20024 20025/** 20026 * Option overwriting strategies are functions that handle 20027 * how to merge a parent option value and a child option 20028 * value into the final value. 20029 */ 20030var strats = config.optionMergeStrategies; 20031/** 20032 * Options with restrictions 20033 */ 20034if (false) {} 20035/** 20036 * Helper that recursively merges two data objects together. 20037 */ 20038function mergeData(to, from, recursive) { 20039 if (recursive === void 0) { recursive = true; } 20040 if (!from) 20041 return to; 20042 var key, toVal, fromVal; 20043 var keys = hasSymbol 20044 ? Reflect.ownKeys(from) 20045 : Object.keys(from); 20046 for (var i = 0; i < keys.length; i++) { 20047 key = keys[i]; 20048 // in case the object is already observed... 20049 if (key === '__ob__') 20050 continue; 20051 toVal = to[key]; 20052 fromVal = from[key]; 20053 if (!recursive || !hasOwn(to, key)) { 20054 set(to, key, fromVal); 20055 } 20056 else if (toVal !== fromVal && 20057 isPlainObject(toVal) && 20058 isPlainObject(fromVal)) { 20059 mergeData(toVal, fromVal); 20060 } 20061 } 20062 return to; 20063} 20064/** 20065 * Data 20066 */ 20067function mergeDataOrFn(parentVal, childVal, vm) { 20068 if (!vm) { 20069 // in a Vue.extend merge, both should be functions 20070 if (!childVal) { 20071 return parentVal; 20072 } 20073 if (!parentVal) { 20074 return childVal; 20075 } 20076 // when parentVal & childVal are both present, 20077 // we need to return a function that returns the 20078 // merged result of both functions... no need to 20079 // check if parentVal is a function here because 20080 // it has to be a function to pass previous merges. 20081 return function mergedDataFn() { 20082 return mergeData(isFunction(childVal) ? childVal.call(this, this) : childVal, isFunction(parentVal) ? parentVal.call(this, this) : parentVal); 20083 }; 20084 } 20085 else { 20086 return function mergedInstanceDataFn() { 20087 // instance merge 20088 var instanceData = isFunction(childVal) 20089 ? childVal.call(vm, vm) 20090 : childVal; 20091 var defaultData = isFunction(parentVal) 20092 ? parentVal.call(vm, vm) 20093 : parentVal;
20094 if (instanceData) { 20095 return mergeData(instanceData, defaultData); 20096 } 20097 else { 20098 return defaultData; 20099 } 20100 }; 20101 } 20102} 20103strats.data = function (parentVal, childVal, vm) { 20104 if (!vm) { 20105 if (childVal && typeof childVal !== 'function') { 20106 false && 20107 0; 20108 return parentVal; 20109 } 20110 return mergeDataOrFn(parentVal, childVal); 20111 } 20112 return mergeDataOrFn(parentVal, childVal, vm); 20113}; 20114/** 20115 * Hooks and props are merged as arrays. 20116 */ 20117function mergeLifecycleHook(parentVal, childVal) { 20118 var res = childVal 20119 ? parentVal 20120 ? parentVal.concat(childVal) 20121 : isArray(childVal) 20122 ? childVal 20123 : [childVal] 20124 : parentVal; 20125 return res ? dedupeHooks(res) : res; 20126} 20127function dedupeHooks(hooks) { 20128 var res = []; 20129 for (var i = 0; i < hooks.length; i++) { 20130 if (res.indexOf(hooks[i]) === -1) { 20131 res.push(hooks[i]); 20132 } 20133 } 20134 return res; 20135} 20136LIFECYCLE_HOOKS.forEach(function (hook) { 20137 strats[hook] = mergeLifecycleHook; 20138}); 20139/** 20140 * Assets 20141 * 20142 * When a vm is present (instance creation), we need to do 20143 * a three-way merge between constructor options, instance 20144 * options and parent options. 20145 */ 20146function mergeAssets(parentVal, childVal, vm, key) { 20147 var res = Object.create(parentVal || null); 20148 if (childVal) { 20149 false && 0; 20150 return extend(res, childVal); 20151 } 20152 else { 20153 return res; 20154 } 20155} 20156ASSET_TYPES.forEach(function (type) { 20157 strats[type + 's'] = mergeAssets; 20158}); 20159/** 20160 * Watchers. 20161 * 20162 * Watchers hashes should not overwrite one 20163 * another, so we merge them as arrays. 20164 */ 20165strats.watch = function (parentVal, childVal, vm, key) { 20166 // work around Firefox's Object.prototype.watch... 20167 //@ts-expect-error work around 20168 if (parentVal === nativeWatch) 20169 parentVal = undefined; 20170 //@ts-expect-error work around 20171 if (childVal === nativeWatch) 20172 childVal = undefined; 20173 /* istanbul ignore if */ 20174 if (!childVal) 20175 return Object.create(parentVal || null); 20176 if (false) {} 20177 if (!parentVal) 20178 return childVal; 20179 var ret = {}; 20180 extend(ret, parentVal); 20181 for (var key_1 in childVal) { 20182 var parent_1 = ret[key_1]; 20183 var child = childVal[key_1]; 20184 if (parent_1 && !isArray(parent_1)) { 20185 parent_1 = [parent_1]; 20186 } 20187 ret[key_1] = parent_1 ? parent_1.concat(child) : isArray(child) ? child : [child]; 20188 } 20189 return ret; 20190}; 20191/** 20192 * Other object hashes. 20193 */ 20194strats.props = 20195 strats.methods = 20196 strats.inject = 20197 strats.computed = 20198 function (parentVal, childVal, vm, key) { 20199 if (childVal && "production" !== 'production') {} 20200 if (!parentVal) 20201 return childVal; 20202 var ret = Object.create(null); 20203 extend(ret, parentVal); 20204 if (childVal) 20205 extend(ret, childVal); 20206 return ret; 20207 }; 20208strats.provide = function (parentVal, childVal) { 20209 if (!parentVal) 20210 return childVal; 20211 return function () { 20212 var ret = Object.create(null); 20213 mergeData(ret, isFunction(parentVal) ? parentVal.call(this) : parentVal); 20214 if (childVal) { 20215 mergeData(ret, isFunction(childVal) ? childVal.call(this) : childVal, false // non-recursive 20216 ); 20217 } 20218 return ret; 20219 }; 20220}; 20221/** 20222 * Default strategy. 20223 */ 20224var defaultStrat = function (parentVal, childVal) { 20225 return childVal === undefined ? parentVal : childVal; 20226}; 20227/** 20228 * Validate component names 20229 */ 20230function checkComponents(options) { 20231 for (var key in options.components) { 20232 validateComponentName(key); 20233 } 20234} 20235function validateComponentName(name) { 20236 if (!new RegExp("^[a-zA-Z][\\-\\.0-9_".concat(unicodeRegExp.source, "]*$")).test(name)) { 20237 warn$2('Invalid component name: "' + 20238 name + 20239 '". Component names ' + 20240 'should conform to valid custom element name in html5 specification.'); 20241 } 20242 if (isBuiltInTag(name) || config.isReservedTag(name)) { 20243 warn$2('Do not use built-in or reserved HTML elements as component ' + 20244 'id: ' + 20245 name); 20246 } 20247} 20248/** 20249 * Ensure all props option syntax are normalized into the 20250 * Object-based format. 20251 */ 20252function normalizeProps(options, vm) { 20253 var props = options.props; 20254 if (!props) 20255 return; 20256 var res = {}; 20257 var i, val, name; 20258 if (isArray(props)) { 20259 i = props.length; 20260 while (i--) { 20261 val = props[i]; 20262 if (typeof val === 'string') { 20263 name = camelize(val); 20264 res[name] = { type: null }; 20265 } 20266 else if (false) {} 20267 } 20268 } 20269 else if (isPlainObject(props)) { 20270 for (var key in props) { 20271 val = props[key]; 20272 name = camelize(key); 20273 res[name] = isPlainObject(val) ? val : { type: val }; 20274 } 20275 } 20276 else if (false) {} 20277 options.props = res; 20278} 20279/** 20280 * Normalize all injections into Object-based format 20281 */ 20282function normalizeInject(options, vm) { 20283 var inject = options.inject; 20284 if (!inject) 20285 return; 20286 var normalized = (options.inject = {}); 20287 if (isArray(inject)) { 20288 for (var i = 0; i < inject.length; i++) { 20289 normalized[inject[i]] = { from: inject[i] }; 20290 } 20291 } 20292 else if (isPlainObject(inject)) { 20293 for (var key in inject) { 20294 var val = inject[key]; 20295 normalized[key] = isPlainObject(val) 20296 ? extend({ from: key }, val) 20297 : { from: val }; 20298 } 20299 } 20300 else if (false) {} 20301} 20302/** 20303 * Normalize raw function directives into object format. 20304 */ 20305function normalizeDirectives$1(options) { 20306 var dirs = options.directives; 20307 if (dirs) { 20308 for (var key in dirs) { 20309 var def = dirs[key]; 20310 if (isFunction(def)) { 20311 dirs[key] = { bind: def, update: def }; 20312 } 20313 } 20314 } 20315} 20316function assertObjectType(name, value, vm) { 20317 if (!isPlainObject(value)) { 20318 warn$2("Invalid value for option \"".concat(name, "\": expected an Object, ") + 20319 "but got ".concat(toRawType(value), "."), vm); 20320 } 20321} 20322/** 20323 * Merge two option objects into a new one. 20324 * Core utility used in both instantiation and inheritance. 20325 */ 20326function mergeOptions(parent, child, vm) { 20327 if (false) {} 20328 if (isFunction(child)) { 20329 // @ts-expect-error 20330 child = child.options; 20331 } 20332 normalizeProps(child, vm); 20333 normalizeInject(child, vm); 20334 normalizeDirectives$1(child); 20335 // Apply extends and mixins on the child options, 20336 // but only if it is a raw options object that isn't 20337 // the result of another mergeOptions call. 20338 // Only merged options has the _base property. 20339 if (!child._base) { 20340 if (child.extends) { 20341 parent = mergeOptions(parent, child.extends, vm); 20342 } 20343 if (child.mixins) { 20344 for (var i = 0, l = child.mixins.length; i < l; i++) { 20345 parent = mergeOptions(parent, child.mixins[i], vm); 20346 } 20347 } 20348 } 20349 var options = {}; 20350 var key; 20351 for (key in parent) { 20352 mergeField(key); 20353 } 20354 for (key in child) { 20355 if (!hasOwn(parent, key)) { 20356 mergeField(key); 20357 } 20358 } 20359 function mergeField(key) { 20360 var strat = strats[key] || defaultStrat; 20361 options[key] = strat(parent[key], child[key], vm, key); 20362 } 20363 return options; 20364} 20365/** 20366 * Resolve an asset. 20367 * This function is used because child instances need access 20368 * to assets defined in its ancestor chain. 20369 */ 20370function resolveAsset(options, type, id, warnMissing) { 20371 /* istanbul ignore if */ 20372 if (typeof id !== 'string') { 20373 return; 20374 } 20375 var assets = options[type]; 20376 // check local registration variations first 20377 if (hasOwn(assets, id)) 20378 return assets[id]; 20379 var camelizedId = camelize(id); 20380 if (hasOwn(assets, camelizedId)) 20381 return assets[camelizedId]; 20382 var PascalCaseId = capitalize(camelizedId); 20383 if (hasOwn(assets, PascalCaseId)) 20384 return assets[PascalCaseId]; 20385 // fallback to prototype chain 20386 var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; 20387 if (false) {} 20388 return res; 20389} 20390 20391function validateProp(key, propOptions, propsData, vm) { 20392 var prop = propOptions[key]; 20393 var absent = !hasOwn(propsData, key); 20394 var value = propsData[key]; 20395 // boolean casting 20396 var booleanIndex = getTypeIndex(Boolean, prop.type); 20397 if (booleanIndex > -1) { 20398 if (absent && !hasOwn(prop, 'default')) { 20399 value = false;
20400 } 20401 else if (value === '' || value === hyphenate(key)) { 20402 // only cast empty string / same name to boolean if 20403 // boolean has higher priority 20404 var stringIndex = getTypeIndex(String, prop.type); 20405 if (stringIndex < 0 || booleanIndex < stringIndex) { 20406 value = true; 20407 } 20408 } 20409 } 20410 // check default value 20411 if (value === undefined) { 20412 value = getPropDefaultValue(vm, prop, key); 20413 // since the default value is a fresh copy, 20414 // make sure to observe it. 20415 var prevShouldObserve = shouldObserve; 20416 toggleObserving(true); 20417 observe(value); 20418 toggleObserving(prevShouldObserve); 20419 } 20420 if (false) {} 20421 return value; 20422} 20423/** 20424 * Get the default value of a prop. 20425 */ 20426function getPropDefaultValue(vm, prop, key) { 20427 // no default, return undefined 20428 if (!hasOwn(prop, 'default')) { 20429 return undefined; 20430 } 20431 var def = prop.default; 20432 // warn against non-factory defaults for Object & Array 20433 if (false) {} 20434 // the raw prop value was also undefined from previous render, 20435 // return previous default value to avoid unnecessary watcher trigger 20436 if (vm && 20437 vm.$options.propsData && 20438 vm.$options.propsData[key] === undefined && 20439 vm._props[key] !== undefined) { 20440 return vm._props[key]; 20441 } 20442 // call factory function for non-Function types 20443 // a value is Function if its prototype is function even across different execution context 20444 return isFunction(def) && getType(prop.type) !== 'Function' 20445 ? def.call(vm) 20446 : def; 20447} 20448/** 20449 * Assert whether a prop is valid. 20450 */ 20451function assertProp(prop, name, value, vm, absent) { 20452 if (prop.required && absent) { 20453 warn$2('Missing required prop: "' + name + '"', vm); 20454 return; 20455 } 20456 if (value == null && !prop.required) { 20457 return; 20458 } 20459 var type = prop.type; 20460 var valid = !type || type === true; 20461 var expectedTypes = []; 20462 if (type) { 20463 if (!isArray(type)) { 20464 type = [type]; 20465 } 20466 for (var i = 0; i < type.length && !valid; i++) { 20467 var assertedType = assertType(value, type[i], vm); 20468 expectedTypes.push(assertedType.expectedType || ''); 20469 valid = assertedType.valid; 20470 } 20471 } 20472 var haveExpectedTypes = expectedTypes.some(function (t) { return t; }); 20473 if (!valid && haveExpectedTypes) { 20474 warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm); 20475 return; 20476 } 20477 var validator = prop.validator; 20478 if (validator) { 20479 if (!validator(value)) { 20480 warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm); 20481 } 20482 } 20483} 20484var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/; 20485function assertType(value, type, vm) { 20486 var valid; 20487 var expectedType = getType(type); 20488 if (simpleCheckRE.test(expectedType)) { 20489 var t = typeof value; 20490 valid = t === expectedType.toLowerCase(); 20491 // for primitive wrapper objects 20492 if (!valid && t === 'object') { 20493 valid = value instanceof type; 20494 } 20495 } 20496 else if (expectedType === 'Object') { 20497 valid = isPlainObject(value); 20498 } 20499 else if (expectedType === 'Array') { 20500 valid = isArray(value); 20501 } 20502 else { 20503 try { 20504 valid = value instanceof type; 20505 } 20506 catch (e) { 20507 warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm); 20508 valid = false; 20509 } 20510 } 20511 return { 20512 valid: valid, 20513 expectedType: expectedType 20514 }; 20515} 20516var functionTypeCheckRE = /^\s*function (\w+)/; 20517/** 20518 * Use function string name to check built-in types, 20519 * because a simple equality check will fail when running 20520 * across different vms / iframes. 20521 */ 20522function getType(fn) { 20523 var match = fn && fn.toString().match(functionTypeCheckRE); 20524 return match ? match[1] : ''; 20525} 20526function isSameType(a, b) { 20527 return getType(a) === getType(b); 20528} 20529function getTypeIndex(type, expectedTypes) { 20530 if (!isArray(expectedTypes)) { 20531 return isSameType(expectedTypes, type) ? 0 : -1; 20532 } 20533 for (var i = 0, len = expectedTypes.length; i < len; i++) { 20534 if (isSameType(expectedTypes[i], type)) { 20535 return i; 20536 } 20537 } 20538 return -1; 20539} 20540function getInvalidTypeMessage(name, value, expectedTypes) { 20541 var message = "Invalid prop: type check failed for prop \"".concat(name, "\".") + 20542 " Expected ".concat(expectedTypes.map(capitalize).join(', ')); 20543 var expectedType = expectedTypes[0]; 20544 var receivedType = toRawType(value); 20545 // check if we need to specify expected value 20546 if (expectedTypes.length === 1 && 20547 isExplicable(expectedType) && 20548 isExplicable(typeof value) && 20549 !isBoolean(expectedType, receivedType)) { 20550 message += " with value ".concat(styleValue(value, expectedType)); 20551 } 20552 message += ", got ".concat(receivedType, " "); 20553 // check if we need to specify received value 20554 if (isExplicable(receivedType)) { 20555 message += "with value ".concat(styleValue(value, receivedType), "."); 20556 } 20557 return message; 20558} 20559function styleValue(value, type) { 20560 if (type === 'String') { 20561 return "\"".concat(value, "\""); 20562 } 20563 else if (type === 'Number') { 20564 return "".concat(Number(value)); 20565 } 20566 else { 20567 return "".concat(value); 20568 } 20569} 20570var EXPLICABLE_TYPES = (/* unused pure expression or super */ null && (['string', 'number', 'boolean'])); 20571function isExplicable(value) { 20572 return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; }); 20573} 20574function isBoolean() { 20575 var args = []; 20576 for (var _i = 0; _i < arguments.length; _i++) { 20577 args[_i] = arguments[_i]; 20578 } 20579 return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; }); 20580} 20581 20582function Vue(options) { 20583 if (false) {} 20584 this._init(options); 20585} 20586//@ts-expect-error Vue has function type 20587initMixin$1(Vue); 20588//@ts-expect-error Vue has function type 20589stateMixin(Vue); 20590//@ts-expect-error Vue has function type 20591eventsMixin(Vue); 20592//@ts-expect-error Vue has function type 20593lifecycleMixin(Vue); 20594//@ts-expect-error Vue has function type 20595renderMixin(Vue); 20596 20597function initUse(Vue) { 20598 Vue.use = function (plugin) { 20599 var installedPlugins = this._installedPlugins || (this._installedPlugins = []); 20600 if (installedPlugins.indexOf(plugin) > -1) { 20601 return this; 20602 } 20603 // additional parameters 20604 var args = toArray(arguments, 1); 20605 args.unshift(this); 20606 if (isFunction(plugin.install)) { 20607 plugin.install.apply(plugin, args); 20608 } 20609 else if (isFunction(plugin)) {
20610 plugin.apply(null, args); 20611 } 20612 installedPlugins.push(plugin); 20613 return this; 20614 }; 20615} 20616 20617function initMixin(Vue) { 20618 Vue.mixin = function (mixin) { 20619 this.options = mergeOptions(this.options, mixin); 20620 return this; 20621 }; 20622} 20623 20624function initExtend(Vue) { 20625 /** 20626 * Each instance constructor, including Vue, has a unique 20627 * cid. This enables us to create wrapped "child 20628 * constructors" for prototypal inheritance and cache them. 20629 */ 20630 Vue.cid = 0; 20631 var cid = 1; 20632 /** 20633 * Class inheritance 20634 */ 20635 Vue.extend = function (extendOptions) { 20636 extendOptions = extendOptions || {}; 20637 var Super = this; 20638 var SuperId = Super.cid; 20639 var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); 20640 if (cachedCtors[SuperId]) { 20641 return cachedCtors[SuperId]; 20642 } 20643 var name = getComponentName(extendOptions) || getComponentName(Super.options); 20644 if (false) {} 20645 var Sub = function VueComponent(options) { 20646 this._init(options); 20647 }; 20648 Sub.prototype = Object.create(Super.prototype); 20649 Sub.prototype.constructor = Sub; 20650 Sub.cid = cid++; 20651 Sub.options = mergeOptions(Super.options, extendOptions); 20652 Sub['super'] = Super; 20653 // For props and computed properties, we define the proxy getters on 20654 // the Vue instances at extension time, on the extended prototype. This 20655 // avoids Object.defineProperty calls for each instance created. 20656 if (Sub.options.props) { 20657 initProps(Sub); 20658 } 20659 if (Sub.options.computed) { 20660 initComputed(Sub); 20661 } 20662 // allow further extension/mixin/plugin usage 20663 Sub.extend = Super.extend; 20664 Sub.mixin = Super.mixin; 20665 Sub.use = Super.use; 20666 // create asset registers, so extended classes 20667 // can have their private assets too. 20668 ASSET_TYPES.forEach(function (type) { 20669 Sub[type] = Super[type]; 20670 }); 20671 // enable recursive self-lookup 20672 if (name) { 20673 Sub.options.components[name] = Sub; 20674 } 20675 // keep a reference to the super options at extension time. 20676 // later at instantiation we can check if Super's options have 20677 // been updated. 20678 Sub.superOptions = Super.options; 20679 Sub.extendOptions = extendOptions; 20680 Sub.sealedOptions = extend({}, Sub.options);
20681 // cache constructor 20682 cachedCtors[SuperId] = Sub; 20683 return Sub; 20684 }; 20685} 20686function initProps(Comp) { 20687 var props = Comp.options.props; 20688 for (var key in props) { 20689 proxy(Comp.prototype, "_props", key); 20690 } 20691} 20692function initComputed(Comp) { 20693 var computed = Comp.options.computed; 20694 for (var key in computed) { 20695 defineComputed(Comp.prototype, key, computed[key]); 20696 } 20697} 20698 20699function initAssetRegisters(Vue) { 20700 /** 20701 * Create asset registration methods. 20702 */ 20703 ASSET_TYPES.forEach(function (type) { 20704 // @ts-expect-error function is not exact same type 20705 Vue[type] = function (id, definition) { 20706 if (!definition) { 20707 return this.options[type + 's'][id]; 20708 } 20709 else { 20710 /* istanbul ignore if */ 20711 if (false) {} 20712 if (type === 'component' && isPlainObject(definition)) { 20713 // @ts-expect-error 20714 definition.name = definition.name || id; 20715 definition = this.options._base.extend(definition); 20716 } 20717 if (type === 'directive' && isFunction(definition)) { 20718 definition = { bind: definition, update: definition }; 20719 } 20720 this.options[type + 's'][id] = definition; 20721 return definition; 20722 } 20723 }; 20724 }); 20725} 20726 20727function _getComponentName(opts) { 20728 return opts && (getComponentName(opts.Ctor.options) || opts.tag); 20729} 20730function matches(pattern, name) { 20731 if (isArray(pattern)) { 20732 return pattern.indexOf(name) > -1; 20733 } 20734 else if (typeof pattern === 'string') { 20735 return pattern.split(',').indexOf(name) > -1; 20736 } 20737 else if (isRegExp(pattern)) { 20738 return pattern.test(name); 20739 } 20740 /* istanbul ignore next */ 20741 return false; 20742} 20743function pruneCache(keepAliveInstance, filter) { 20744 var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode, $vnode = keepAliveInstance.$vnode; 20745 for (var key in cache) { 20746 var entry = cache[key]; 20747 if (entry) { 20748 var name_1 = entry.name; 20749 if (name_1 && !filter(name_1)) { 20750 pruneCacheEntry(cache, key, keys, _vnode); 20751 } 20752 } 20753 } 20754 $vnode.componentOptions.children = undefined; 20755} 20756function pruneCacheEntry(cache, key, keys, current) { 20757 var entry = cache[key]; 20758 if (entry && (!current || entry.tag !== current.tag)) { 20759 // @ts-expect-error can be undefined 20760 entry.componentInstance.$destroy(); 20761 } 20762 cache[key] = null; 20763 remove$2(keys, key); 20764} 20765var patternTypes = [String, RegExp, Array]; 20766// TODO defineComponent 20767var KeepAlive = { 20768 name: 'keep-alive', 20769 abstract: true, 20770 props: { 20771 include: patternTypes, 20772 exclude: patternTypes, 20773 max: [String, Number] 20774 }, 20775 methods: { 20776 cacheVNode: function () { 20777 var _a = this, cache = _a.cache, keys = _a.keys, vnodeToCache = _a.vnodeToCache, keyToCache = _a.keyToCache; 20778 if (vnodeToCache) { 20779 var tag = vnodeToCache.tag, componentInstance = vnodeToCache.componentInstance, componentOptions = vnodeToCache.componentOptions; 20780 cache[keyToCache] = { 20781 name: _getComponentName(componentOptions), 20782 tag: tag, 20783 componentInstance: componentInstance 20784 }; 20785 keys.push(keyToCache); 20786 // prune oldest entry 20787 if (this.max && keys.length > parseInt(this.max)) { 20788 pruneCacheEntry(cache, keys[0], keys, this._vnode); 20789 } 20790 this.vnodeToCache = null; 20791 } 20792 } 20793 }, 20794 created: function () { 20795 this.cache = Object.create(null); 20796 this.keys = []; 20797 }, 20798 destroyed: function () { 20799 for (var key in this.cache) { 20800 pruneCacheEntry(this.cache, key, this.keys); 20801 } 20802 }, 20803 mounted: function () { 20804 var _this = this; 20805 this.cacheVNode(); 20806 this.$watch('include', function (val) { 20807 pruneCache(_this, function (name) { return matches(val, name); }); 20808 }); 20809 this.$watch('exclude', function (val) { 20810 pruneCache(_this, function (name) { return !matches(val, name); }); 20811 }); 20812 }, 20813 updated: function () { 20814 this.cacheVNode(); 20815 }, 20816 render: function () { 20817 var slot = this.$slots.default; 20818 var vnode = getFirstComponentChild(slot); 20819 var componentOptions = vnode && vnode.componentOptions; 20820 if (componentOptions) { 20821 // check pattern 20822 var name_2 = _getComponentName(componentOptions); 20823 var _a = this, include = _a.include, exclude = _a.exclude; 20824 if ( 20825 // not included 20826 (include && (!name_2 || !matches(include, name_2))) || 20827 // excluded 20828 (exclude && name_2 && matches(exclude, name_2))) { 20829 return vnode; 20830 } 20831 var _b = this, cache = _b.cache, keys = _b.keys; 20832 var key = vnode.key == null 20833 ? // same constructor may get registered as different local components 20834 // so cid alone is not enough (#3269) 20835 componentOptions.Ctor.cid + 20836 (componentOptions.tag ? "::".concat(componentOptions.tag) : '') 20837 : vnode.key; 20838 if (cache[key]) {
20839 vnode.componentInstance = cache[key].componentInstance; 20840 // make current key freshest 20841 remove$2(keys, key); 20842 keys.push(key); 20843 } 20844 else { 20845 // delay setting the cache until update 20846 this.vnodeToCache = vnode; 20847 this.keyToCache = key; 20848 } 20849 // @ts-expect-error can vnode.data can be undefined 20850 vnode.data.keepAlive = true; 20851 } 20852 return vnode || (slot && slot[0]); 20853 } 20854}; 20855 20856var builtInComponents = { 20857 KeepAlive: KeepAlive 20858}; 20859 20860function initGlobalAPI(Vue) { 20861 // config 20862 var configDef = {}; 20863 configDef.get = function () { return config; }; 20864 if (false) {} 20865 Object.defineProperty(Vue, 'config', configDef); 20866 // exposed util methods. 20867 // NOTE: these are not considered part of the public API - avoid relying on 20868 // them unless you are aware of the risk. 20869 Vue.util = { 20870 warn: warn$2, 20871 extend: extend, 20872 mergeOptions: mergeOptions, 20873 defineReactive: defineReactive 20874 }; 20875 Vue.set = set; 20876 Vue.delete = del; 20877 Vue.nextTick = nextTick; 20878 // 2.6 explicit observable API 20879 Vue.observable = function (obj) { 20880 observe(obj); 20881 return obj; 20882 }; 20883 Vue.options = Object.create(null); 20884 ASSET_TYPES.forEach(function (type) { 20885 Vue.options[type + 's'] = Object.create(null); 20886 }); 20887 // this is used to identify the "base" constructor to extend all plain-object 20888 // components with in Weex's multi-instance scenarios. 20889 Vue.options._base = Vue; 20890 extend(Vue.options.components, builtInComponents); 20891 initUse(Vue); 20892 initMixin(Vue); 20893 initExtend(Vue); 20894 initAssetRegisters(Vue); 20895} 20896 20897initGlobalAPI(Vue); 20898Object.defineProperty(Vue.prototype, '$isServer', { 20899 get: isServerRendering 20900}); 20901Object.defineProperty(Vue.prototype, '$ssrContext', { 20902 get: function () { 20903 /* istanbul ignore next */ 20904 return this.$vnode && this.$vnode.ssrContext; 20905 } 20906}); 20907// expose FunctionalRenderContext for ssr runtime helper installation 20908Object.defineProperty(Vue, 'FunctionalRenderContext', { 20909 value: FunctionalRenderContext 20910}); 20911Vue.version = version; 20912 20913// these are reserved for web because they are directly compiled away 20914// during template compilation 20915var isReservedAttr = makeMap('style,class'); 20916// attributes that should be using props for binding 20917var acceptValue = makeMap('input,textarea,option,select,progress'); 20918var mustUseProp = function (tag, type, attr) { 20919 return ((attr === 'value' && acceptValue(tag) && type !== 'button') || 20920 (attr === 'selected' && tag === 'option') || 20921 (attr === 'checked' && tag === 'input') || 20922 (attr === 'muted' && tag === 'video')); 20923}; 20924var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); 20925var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only'); 20926var convertEnumeratedValue = function (key, value) { 20927 return isFalsyAttrValue(value) || value === 'false' 20928 ? 'false' 20929 : // allow arbitrary string value for contenteditable 20930 key === 'contenteditable' && isValidContentEditableValue(value) 20931 ? value 20932 : 'true'; 20933}; 20934var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 20935 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 20936 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 20937 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 20938 'required,reversed,scoped,seamless,selected,sortable,' + 20939 'truespeed,typemustmatch,visible'); 20940var xlinkNS = 'http://www.w3.org/1999/xlink'; 20941var isXlink = function (name) { 20942 return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'; 20943}; 20944var getXlinkProp = function (name) { 20945 return isXlink(name) ? name.slice(6, name.length) : ''; 20946}; 20947var isFalsyAttrValue = function (val) { 20948 return val == null || val === false; 20949}; 20950 20951function genClassForVnode(vnode) { 20952 var data = vnode.data; 20953 var parentNode = vnode; 20954 var childNode = vnode; 20955 while (isDef(childNode.componentInstance)) { 20956 childNode = childNode.componentInstance._vnode; 20957 if (childNode && childNode.data) { 20958 data = mergeClassData(childNode.data, data); 20959 } 20960 } 20961 // @ts-expect-error parentNode.parent not VNodeWithData 20962 while (isDef((parentNode = parentNode.parent))) { 20963 if (parentNode && parentNode.data) { 20964 data = mergeClassData(data, parentNode.data); 20965 } 20966 } 20967 return renderClass(data.staticClass, data.class); 20968} 20969function mergeClassData(child, parent) { 20970 return { 20971 staticClass: concat(child.staticClass, parent.staticClass), 20972 class: isDef(child.class) ? [child.class, parent.class] : parent.class 20973 }; 20974} 20975function renderClass(staticClass, dynamicClass) { 20976 if (isDef(staticClass) || isDef(dynamicClass)) { 20977 return concat(staticClass, stringifyClass(dynamicClass)); 20978 } 20979 /* istanbul ignore next */ 20980 return ''; 20981} 20982function concat(a, b) { 20983 return a ? (b ? a + ' ' + b : a) : b || ''; 20984} 20985function stringifyClass(value) { 20986 if (Array.isArray(value)) { 20987 return stringifyArray(value); 20988 } 20989 if (isObject(value)) { 20990 return stringifyObject(value); 20991 } 20992 if (typeof value === 'string') { 20993 return value; 20994 } 20995 /* istanbul ignore next */ 20996 return ''; 20997} 20998function stringifyArray(value) { 20999 var res = ''; 21000 var stringified; 21001 for (var i = 0, l = value.length; i < l; i++) { 21002 if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') { 21003 if (res) 21004 res += ' '; 21005 res += stringified; 21006 } 21007 } 21008 return res; 21009} 21010function stringifyObject(value) { 21011 var res = ''; 21012 for (var key in value) { 21013 if (value[key]) { 21014 if (res) 21015 res += ' '; 21016 res += key; 21017 } 21018 } 21019 return res; 21020} 21021 21022var namespaceMap = { 21023 svg: 'http://www.w3.org/2000/svg', 21024 math: 'http://www.w3.org/1998/Math/MathML' 21025}; 21026var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' + 21027 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 21028 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 21029 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 21030 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 21031 'embed,object,param,source,canvas,script,noscript,del,ins,' + 21032 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 21033 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 21034 'output,progress,select,textarea,' + 21035 'details,dialog,menu,menuitem,summary,' + 21036 'content,element,shadow,template,blockquote,iframe,tfoot'); 21037// this map is intentionally selective, only covering SVG elements that may 21038// contain child elements. 21039var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 21040 'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 21041 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true); 21042var isPreTag = function (tag) { return tag === 'pre'; }; 21043var isReservedTag = function (tag) { 21044 return isHTMLTag(tag) || isSVG(tag); 21045}; 21046function getTagNamespace(tag) { 21047 if (isSVG(tag)) { 21048 return 'svg'; 21049 } 21050 // basic support for MathML 21051 // note it doesn't support other MathML elements being component roots 21052 if (tag === 'math') { 21053 return 'math'; 21054 } 21055} 21056var unknownElementCache = Object.create(null); 21057function isUnknownElement(tag) { 21058 /* istanbul ignore if */ 21059 if (!inBrowser) { 21060 return true; 21061 } 21062 if (isReservedTag(tag)) { 21063 return false;
21064 } 21065 tag = tag.toLowerCase(); 21066 /* istanbul ignore if */ 21067 if (unknownElementCache[tag] != null) { 21068 return unknownElementCache[tag]; 21069 } 21070 var el = document.createElement(tag); 21071 if (tag.indexOf('-') > -1) { 21072 // https://stackoverflow.com/a/28210364/1070244 21073 return (unknownElementCache[tag] = 21074 el.constructor === window.HTMLUnknownElement || 21075 el.constructor === window.HTMLElement); 21076 } 21077 else { 21078 return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())); 21079 } 21080} 21081var isTextInputType = makeMap('text,number,password,search,email,tel,url'); 21082 21083/** 21084 * Query an element selector if it's not an element already. 21085 */ 21086function query(el) { 21087 if (typeof el === 'string') { 21088 var selected = document.querySelector(el); 21089 if (!selected) { 21090 false && 0; 21091 return document.createElement('div'); 21092 } 21093 return selected; 21094 } 21095 else { 21096 return el; 21097 } 21098} 21099 21100function createElement(tagName, vnode) { 21101 var elm = document.createElement(tagName); 21102 if (tagName !== 'select') { 21103 return elm; 21104 } 21105 // false or null will remove the attribute but undefined will not 21106 if (vnode.data && 21107 vnode.data.attrs && 21108 vnode.data.attrs.multiple !== undefined) { 21109 elm.setAttribute('multiple', 'multiple'); 21110 } 21111 return elm; 21112} 21113function createElementNS(namespace, tagName) { 21114 return document.createElementNS(namespaceMap[namespace], tagName); 21115} 21116function createTextNode(text) { 21117 return document.createTextNode(text); 21118} 21119function createComment(text) { 21120 return document.createComment(text); 21121} 21122function insertBefore(parentNode, newNode, referenceNode) { 21123 parentNode.insertBefore(newNode, referenceNode); 21124} 21125function removeChild(node, child) { 21126 node.removeChild(child); 21127} 21128function appendChild(node, child) { 21129 node.appendChild(child); 21130} 21131function parentNode(node) { 21132 return node.parentNode; 21133} 21134function nextSibling(node) { 21135 return node.nextSibling; 21136} 21137function tagName(node) { 21138 return node.tagName; 21139} 21140function setTextContent(node, text) { 21141 node.textContent = text; 21142} 21143function setStyleScope(node, scopeId) { 21144 node.setAttribute(scopeId, ''); 21145} 21146 21147var nodeOps = /*#__PURE__*/Object.freeze({ 21148 __proto__: null, 21149 createElement: createElement, 21150 createElementNS: createElementNS, 21151 createTextNode: createTextNode, 21152 createComment: createComment, 21153 insertBefore: insertBefore, 21154 removeChild: removeChild, 21155 appendChild: appendChild, 21156 parentNode: parentNode, 21157 nextSibling: nextSibling, 21158 tagName: tagName, 21159 setTextContent: setTextContent, 21160 setStyleScope: setStyleScope 21161}); 21162 21163var ref = { 21164 create: function (_, vnode) { 21165 registerRef(vnode); 21166 }, 21167 update: function (oldVnode, vnode) { 21168 if (oldVnode.data.ref !== vnode.data.ref) { 21169 registerRef(oldVnode, true); 21170 registerRef(vnode); 21171 } 21172 }, 21173 destroy: function (vnode) { 21174 registerRef(vnode, true); 21175 } 21176}; 21177function registerRef(vnode, isRemoval) { 21178 var ref = vnode.data.ref; 21179 if (!isDef(ref)) 21180 return; 21181 var vm = vnode.context; 21182 var refValue = vnode.componentInstance || vnode.elm; 21183 var value = isRemoval ? null : refValue; 21184 var $refsValue = isRemoval ? undefined : refValue; 21185 if (isFunction(ref)) { 21186 invokeWithErrorHandling(ref, vm, [value], vm, "template ref function"); 21187 return; 21188 } 21189 var isFor = vnode.data.refInFor; 21190 var _isString = typeof ref === 'string' || typeof ref === 'number'; 21191 var _isRef = isRef(ref); 21192 var refs = vm.$refs; 21193 if (_isString || _isRef) { 21194 if (isFor) { 21195 var existing = _isString ? refs[ref] : ref.value; 21196 if (isRemoval) { 21197 isArray(existing) && remove$2(existing, refValue); 21198 } 21199 else { 21200 if (!isArray(existing)) { 21201 if (_isString) { 21202 refs[ref] = [refValue]; 21203 setSetupRef(vm, ref, refs[ref]); 21204 } 21205 else { 21206 ref.value = [refValue]; 21207 } 21208 } 21209 else if (!existing.includes(refValue)) { 21210 existing.push(refValue); 21211 } 21212 } 21213 } 21214 else if (_isString) { 21215 if (isRemoval && refs[ref] !== refValue) { 21216 return; 21217 } 21218 refs[ref] = $refsValue; 21219 setSetupRef(vm, ref, value); 21220 } 21221 else if (_isRef) { 21222 if (isRemoval && ref.value !== refValue) { 21223 return; 21224 } 21225 ref.value = value; 21226 } 21227 else if (false) {} 21228 } 21229} 21230function setSetupRef(_a, key, val) { 21231 var _setupState = _a._setupState; 21232 if (_setupState && hasOwn(_setupState, key)) { 21233 if (isRef(_setupState[key])) { 21234 _setupState[key].value = val; 21235 } 21236 else { 21237 _setupState[key] = val; 21238 } 21239 } 21240} 21241 21242/** 21243 * Virtual DOM patching algorithm based on Snabbdom by 21244 * Simon Friis Vindum (@paldepind) 21245 * Licensed under the MIT License 21246 * https://github.com/paldepind/snabbdom/blob/master/LICENSE 21247 * 21248 * modified by Evan You (@yyx990803) 21249 * 21250 * Not type-checking this because this file is perf-critical and the cost 21251 * of making flow understand it is not worth it. 21252 */ 21253var emptyNode = new VNode('', {}, []); 21254var hooks = ['create', 'activate', 'update', 'remove', 'destroy']; 21255function sameVnode(a, b) {
21256 return (a.key === b.key && 21257 a.asyncFactory === b.asyncFactory && 21258 ((a.tag === b.tag && 21259 a.isComment === b.isComment && 21260 isDef(a.data) === isDef(b.data) && 21261 sameInputType(a, b)) || 21262 (isTrue(a.isAsyncPlaceholder) && isUndef(b.asyncFactory.error)))); 21263} 21264function sameInputType(a, b) { 21265 if (a.tag !== 'input') 21266 return true; 21267 var i; 21268 var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type; 21269 var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type; 21270 return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB)); 21271} 21272function createKeyToOldIdx(children, beginIdx, endIdx) { 21273 var i, key; 21274 var map = {}; 21275 for (i = beginIdx; i <= endIdx; ++i) { 21276 key = children[i].key; 21277 if (isDef(key)) 21278 map[key] = i; 21279 } 21280 return map; 21281} 21282function createPatchFunction(backend) { 21283 var i, j; 21284 var cbs = {}; 21285 var modules = backend.modules, nodeOps = backend.nodeOps; 21286 for (i = 0; i < hooks.length; ++i) { 21287 cbs[hooks[i]] = []; 21288 for (j = 0; j < modules.length; ++j) { 21289 if (isDef(modules[j][hooks[i]])) { 21290 cbs[hooks[i]].push(modules[j][hooks[i]]); 21291 } 21292 } 21293 } 21294 function emptyNodeAt(elm) { 21295 return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm); 21296 } 21297 function createRmCb(childElm, listeners) { 21298 function remove() { 21299 if (--remove.listeners === 0) { 21300 removeNode(childElm); 21301 } 21302 } 21303 remove.listeners = listeners; 21304 return remove; 21305 } 21306 function removeNode(el) { 21307 var parent = nodeOps.parentNode(el); 21308 // element may have already been removed due to v-html / v-text 21309 if (isDef(parent)) { 21310 nodeOps.removeChild(parent, el); 21311 } 21312 } 21313 function isUnknownElement(vnode, inVPre) { 21314 return (!inVPre && 21315 !vnode.ns && 21316 !(config.ignoredElements.length && 21317 config.ignoredElements.some(function (ignore) { 21318 return isRegExp(ignore) 21319 ? ignore.test(vnode.tag) 21320 : ignore === vnode.tag; 21321 })) && 21322 config.isUnknownElement(vnode.tag)); 21323 } 21324 var creatingElmInVPre = 0; 21325 function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
21326 if (isDef(vnode.elm) && isDef(ownerArray)) { 21327 // This vnode was used in a previous render! 21328 // now it's used as a new node, overwriting its elm would cause 21329 // potential patch errors down the road when it's used as an insertion 21330 // reference node. Instead, we clone the node on-demand before creating 21331 // associated DOM element for it. 21332 vnode = ownerArray[index] = cloneVNode(vnode); 21333 } 21334 vnode.isRootInsert = !nested; // for transition enter check 21335 if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { 21336 return; 21337 } 21338 var data = vnode.data; 21339 var children = vnode.children; 21340 var tag = vnode.tag; 21341 if (isDef(tag)) { 21342 if (false) {} 21343 vnode.elm = vnode.ns 21344 ? nodeOps.createElementNS(vnode.ns, tag) 21345 : nodeOps.createElement(tag, vnode); 21346 setScope(vnode); 21347 createChildren(vnode, children, insertedVnodeQueue); 21348 if (isDef(data)) { 21349 invokeCreateHooks(vnode, insertedVnodeQueue); 21350 } 21351 insert(parentElm, vnode.elm, refElm); 21352 if (false) {} 21353 } 21354 else if (isTrue(vnode.isComment)) { 21355 vnode.elm = nodeOps.createComment(vnode.text); 21356 insert(parentElm, vnode.elm, refElm); 21357 } 21358 else { 21359 vnode.elm = nodeOps.createTextNode(vnode.text); 21360 insert(parentElm, vnode.elm, refElm); 21361 } 21362 } 21363 function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) { 21364 var i = vnode.data; 21365 if (isDef(i)) { 21366 var isReactivated = isDef(vnode.componentInstance) && i.keepAlive; 21367 if (isDef((i = i.hook)) && isDef((i = i.init))) { 21368 i(vnode, false /* hydrating */); 21369 } 21370 // after calling the init hook, if the vnode is a child component 21371 // it should've created a child instance and mounted it. the child 21372 // component also has set the placeholder vnode's elm. 21373 // in that case we can just return the element and be done.
21374 if (isDef(vnode.componentInstance)) { 21375 initComponent(vnode, insertedVnodeQueue); 21376 insert(parentElm, vnode.elm, refElm); 21377 if (isTrue(isReactivated)) { 21378 reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); 21379 } 21380 return true; 21381 } 21382 } 21383 } 21384 function initComponent(vnode, insertedVnodeQueue) { 21385 if (isDef(vnode.data.pendingInsert)) { 21386 insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); 21387 vnode.data.pendingInsert = null; 21388 } 21389 vnode.elm = vnode.componentInstance.$el; 21390 if (isPatchable(vnode)) { 21391 invokeCreateHooks(vnode, insertedVnodeQueue); 21392 setScope(vnode); 21393 } 21394 else { 21395 // empty component root. 21396 // skip all element-related modules except for ref (#3455) 21397 registerRef(vnode); 21398 // make sure to invoke the insert hook 21399 insertedVnodeQueue.push(vnode); 21400 } 21401 } 21402 function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) { 21403 var i; 21404 // hack for #4339: a reactivated component with inner transition 21405 // does not trigger because the inner node's created hooks are not called 21406 // again. It's not ideal to involve module-specific logic in here but 21407 // there doesn't seem to be a better way to do it. 21408 var innerNode = vnode; 21409 while (innerNode.componentInstance) { 21410 innerNode = innerNode.componentInstance._vnode; 21411 if (isDef((i = innerNode.data)) && isDef((i = i.transition))) { 21412 for (i = 0; i < cbs.activate.length; ++i) { 21413 cbs.activate[i](emptyNode, innerNode); 21414 } 21415 insertedVnodeQueue.push(innerNode); 21416 break; 21417 } 21418 } 21419 // unlike a newly created component, 21420 // a reactivated keep-alive component doesn't insert itself 21421 insert(parentElm, vnode.elm, refElm); 21422 } 21423 function insert(parent, elm, ref) { 21424 if (isDef(parent)) { 21425 if (isDef(ref)) { 21426 if (nodeOps.parentNode(ref) === parent) { 21427 nodeOps.insertBefore(parent, elm, ref); 21428 } 21429 } 21430 else { 21431 nodeOps.appendChild(parent, elm); 21432 } 21433 } 21434 } 21435 function createChildren(vnode, children, insertedVnodeQueue) { 21436 if (isArray(children)) { 21437 if (false) {} 21438 for (var i_1 = 0; i_1 < children.length; ++i_1) { 21439 createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1); 21440 } 21441 } 21442 else if (isPrimitive(vnode.text)) { 21443 nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text))); 21444 } 21445 } 21446 function isPatchable(vnode) { 21447 while (vnode.componentInstance) { 21448 vnode = vnode.componentInstance._vnode; 21449 } 21450 return isDef(vnode.tag); 21451 } 21452 function invokeCreateHooks(vnode, insertedVnodeQueue) { 21453 for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) { 21454 cbs.create[i_2](emptyNode, vnode); 21455 } 21456 i = vnode.data.hook; // Reuse variable 21457 if (isDef(i)) { 21458 if (isDef(i.create)) 21459 i.create(emptyNode, vnode); 21460 if (isDef(i.insert)) 21461 insertedVnodeQueue.push(vnode); 21462 } 21463 } 21464 // set scope id attribute for scoped CSS. 21465 // this is implemented as a special case to avoid the overhead 21466 // of going through the normal attribute patching process. 21467 function setScope(vnode) { 21468 var i; 21469 if (isDef((i = vnode.fnScopeId))) { 21470 nodeOps.setStyleScope(vnode.elm, i); 21471 } 21472 else { 21473 var ancestor = vnode; 21474 while (ancestor) { 21475 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) { 21476 nodeOps.setStyleScope(vnode.elm, i); 21477 } 21478 ancestor = ancestor.parent; 21479 } 21480 } 21481 // for slot content they should also get the scopeId from the host instance. 21482 if (isDef((i = activeInstance)) && 21483 i !== vnode.context && 21484 i !== vnode.fnContext && 21485 isDef((i = i.$options._scopeId))) { 21486 nodeOps.setStyleScope(vnode.elm, i); 21487 } 21488 } 21489 function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { 21490 for (; startIdx <= endIdx; ++startIdx) { 21491 createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx); 21492 } 21493 } 21494 function invokeDestroyHook(vnode) { 21495 var i, j; 21496 var data = vnode.data; 21497 if (isDef(data)) { 21498 if (isDef((i = data.hook)) && isDef((i = i.destroy))) 21499 i(vnode); 21500 for (i = 0; i < cbs.destroy.length; ++i) 21501 cbs.destroy[i](vnode); 21502 } 21503 if (isDef((i = vnode.children))) { 21504 for (j = 0; j < vnode.children.length; ++j) { 21505 invokeDestroyHook(vnode.children[j]); 21506 } 21507 } 21508 } 21509 function removeVnodes(vnodes, startIdx, endIdx) { 21510 for (; startIdx <= endIdx; ++startIdx) { 21511 var ch = vnodes[startIdx]; 21512 if (isDef(ch)) { 21513 if (isDef(ch.tag)) { 21514 removeAndInvokeRemoveHook(ch); 21515 invokeDestroyHook(ch); 21516 } 21517 else { 21518 // Text node 21519 removeNode(ch.elm); 21520 } 21521 } 21522 } 21523 } 21524 function removeAndInvokeRemoveHook(vnode, rm) { 21525 if (isDef(rm) || isDef(vnode.data)) { 21526 var i_3; 21527 var listeners = cbs.remove.length + 1; 21528 if (isDef(rm)) { 21529 // we have a recursively passed down rm callback 21530 // increase the listeners count 21531 rm.listeners += listeners; 21532 } 21533 else { 21534 // directly removing 21535 rm = createRmCb(vnode.elm, listeners); 21536 } 21537 // recursively invoke hooks on child component root node 21538 if (isDef((i_3 = vnode.componentInstance)) && 21539 isDef((i_3 = i_3._vnode)) && 21540 isDef(i_3.data)) { 21541 removeAndInvokeRemoveHook(i_3, rm); 21542 } 21543 for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) { 21544 cbs.remove[i_3](vnode, rm); 21545 } 21546 if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) { 21547 i_3(vnode, rm); 21548 } 21549 else { 21550 rm(); 21551 } 21552 } 21553 else { 21554 removeNode(vnode.elm); 21555 } 21556 } 21557 function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { 21558 var oldStartIdx = 0; 21559 var newStartIdx = 0; 21560 var oldEndIdx = oldCh.length - 1; 21561 var oldStartVnode = oldCh[0]; 21562 var oldEndVnode = oldCh[oldEndIdx];
21563 var newEndIdx = newCh.length - 1; 21564 var newStartVnode = newCh[0]; 21565 var newEndVnode = newCh[newEndIdx]; 21566 var oldKeyToIdx, idxInOld, vnodeToMove, refElm; 21567 // removeOnly is a special flag used only by <transition-group> 21568 // to ensure removed elements stay in correct relative positions 21569 // during leaving transitions 21570 var canMove = !removeOnly; 21571 if (false) {} 21572 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { 21573 if (isUndef(oldStartVnode)) { 21574 oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left 21575 } 21576 else if (isUndef(oldEndVnode)) { 21577 oldEndVnode = oldCh[--oldEndIdx]; 21578 } 21579 else if (sameVnode(oldStartVnode, newStartVnode)) { 21580 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 21581 oldStartVnode = oldCh[++oldStartIdx]; 21582 newStartVnode = newCh[++newStartIdx]; 21583 } 21584 else if (sameVnode(oldEndVnode, newEndVnode)) { 21585 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); 21586 oldEndVnode = oldCh[--oldEndIdx]; 21587 newEndVnode = newCh[--newEndIdx]; 21588 } 21589 else if (sameVnode(oldStartVnode, newEndVnode)) { 21590 // Vnode moved right 21591 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); 21592 canMove && 21593 nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); 21594 oldStartVnode = oldCh[++oldStartIdx]; 21595 newEndVnode = newCh[--newEndIdx]; 21596 } 21597 else if (sameVnode(oldEndVnode, newStartVnode)) { 21598 // Vnode moved left 21599 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 21600 canMove && 21601 nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); 21602 oldEndVnode = oldCh[--oldEndIdx]; 21603 newStartVnode = newCh[++newStartIdx]; 21604 } 21605 else { 21606 if (isUndef(oldKeyToIdx)) 21607 oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); 21608 idxInOld = isDef(newStartVnode.key) 21609 ? oldKeyToIdx[newStartVnode.key] 21610 : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); 21611 if (isUndef(idxInOld)) { 21612 // New element 21613 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); 21614 } 21615 else { 21616 vnodeToMove = oldCh[idxInOld]; 21617 if (sameVnode(vnodeToMove, newStartVnode)) { 21618 patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 21619 oldCh[idxInOld] = undefined; 21620 canMove && 21621 nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); 21622 } 21623 else { 21624 // same key but different element. treat as new element 21625 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); 21626 } 21627 } 21628 newStartVnode = newCh[++newStartIdx]; 21629 } 21630 } 21631 if (oldStartIdx > oldEndIdx) { 21632 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; 21633 addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); 21634 } 21635 else if (newStartIdx > newEndIdx) { 21636 removeVnodes(oldCh, oldStartIdx, oldEndIdx); 21637 } 21638 } 21639 function checkDuplicateKeys(children) { 21640 var seenKeys = {}; 21641 for (var i_4 = 0; i_4 < children.length; i_4++) { 21642 var vnode = children[i_4]; 21643 var key = vnode.key; 21644 if (isDef(key)) { 21645 if (seenKeys[key]) { 21646 warn$2("Duplicate keys detected: '".concat(key, "'. This may cause an update error."), vnode.context); 21647 } 21648 else { 21649 seenKeys[key] = true; 21650 } 21651 } 21652 } 21653 } 21654 function findIdxInOld(node, oldCh, start, end) { 21655 for (var i_5 = start; i_5 < end; i_5++) { 21656 var c = oldCh[i_5]; 21657 if (isDef(c) && sameVnode(node, c)) 21658 return i_5; 21659 } 21660 } 21661 function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) { 21662 if (oldVnode === vnode) { 21663 return; 21664 }
21665 if (isDef(vnode.elm) && isDef(ownerArray)) { 21666 // clone reused vnode 21667 vnode = ownerArray[index] = cloneVNode(vnode); 21668 } 21669 var elm = (vnode.elm = oldVnode.elm); 21670 if (isTrue(oldVnode.isAsyncPlaceholder)) { 21671 if (isDef(vnode.asyncFactory.resolved)) { 21672 hydrate(oldVnode.elm, vnode, insertedVnodeQueue); 21673 } 21674 else { 21675 vnode.isAsyncPlaceholder = true; 21676 } 21677 return; 21678 } 21679 // reuse element for static trees. 21680 // note we only do this if the vnode is cloned - 21681 // if the new node is not cloned it means the render functions have been 21682 // reset by the hot-reload-api and we need to do a proper re-render. 21683 if (isTrue(vnode.isStatic) && 21684 isTrue(oldVnode.isStatic) && 21685 vnode.key === oldVnode.key && 21686 (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) { 21687 vnode.componentInstance = oldVnode.componentInstance; 21688 return; 21689 } 21690 var i; 21691 var data = vnode.data; 21692 if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) { 21693 i(oldVnode, vnode); 21694 } 21695 var oldCh = oldVnode.children; 21696 var ch = vnode.children; 21697 if (isDef(data) && isPatchable(vnode)) { 21698 for (i = 0; i < cbs.update.length; ++i) 21699 cbs.update[i](oldVnode, vnode); 21700 if (isDef((i = data.hook)) && isDef((i = i.update))) 21701 i(oldVnode, vnode); 21702 } 21703 if (isUndef(vnode.text)) { 21704 if (isDef(oldCh) && isDef(ch)) { 21705 if (oldCh !== ch) 21706 updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); 21707 } 21708 else if (isDef(ch)) { 21709 if (false) {} 21710 if (isDef(oldVnode.text)) 21711 nodeOps.setTextContent(elm, ''); 21712 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); 21713 } 21714 else if (isDef(oldCh)) { 21715 removeVnodes(oldCh, 0, oldCh.length - 1); 21716 } 21717 else if (isDef(oldVnode.text)) { 21718 nodeOps.setTextContent(elm, ''); 21719 } 21720 } 21721 else if (oldVnode.text !== vnode.text) { 21722 nodeOps.setTextContent(elm, vnode.text); 21723 } 21724 if (isDef(data)) { 21725 if (isDef((i = data.hook)) && isDef((i = i.postpatch))) 21726 i(oldVnode, vnode); 21727 } 21728 } 21729 function invokeInsertHook(vnode, queue, initial) { 21730 // delay insert hooks for component root nodes, invoke them after the 21731 // element is really inserted 21732 if (isTrue(initial) && isDef(vnode.parent)) { 21733 vnode.parent.data.pendingInsert = queue; 21734 } 21735 else { 21736 for (var i_6 = 0; i_6 < queue.length; ++i_6) { 21737 queue[i_6].data.hook.insert(queue[i_6]); 21738 } 21739 } 21740 } 21741 var hydrationBailed = false; 21742 // list of modules that can skip create hook during hydration because they 21743 // are already rendered on the client or has no need for initialization 21744 // Note: style is excluded because it relies on initial clone for future 21745 // deep updates (#7063). 21746 var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key'); 21747 // Note: this is a browser-only function so we can assume elms are DOM nodes. 21748 function hydrate(elm, vnode, insertedVnodeQueue, inVPre) { 21749 var i; 21750 var tag = vnode.tag, data = vnode.data, children = vnode.children; 21751 inVPre = inVPre || (data && data.pre); 21752 vnode.elm = elm; 21753 if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { 21754 vnode.isAsyncPlaceholder = true; 21755 return true; 21756 } 21757 // assert node match 21758 if (false) {} 21759 if (isDef(data)) { 21760 if (isDef((i = data.hook)) && isDef((i = i.init))) 21761 i(vnode, true /* hydrating */); 21762 if (isDef((i = vnode.componentInstance))) { 21763 // child component. it should have hydrated its own tree. 21764 initComponent(vnode, insertedVnodeQueue); 21765 return true; 21766 } 21767 } 21768 if (isDef(tag)) { 21769 if (isDef(children)) { 21770 // empty element, allow client to pick up and populate children 21771 if (!elm.hasChildNodes()) { 21772 createChildren(vnode, children, insertedVnodeQueue); 21773 } 21774 else { 21775 // v-html and domProps: innerHTML 21776 if (isDef((i = data)) && 21777 isDef((i = i.domProps)) && 21778 isDef((i = i.innerHTML))) { 21779 if (i !== elm.innerHTML) { 21780 /* istanbul ignore if */ 21781 if (false) {} 21782 return false;
21783 } 21784 } 21785 else { 21786 // iterate and compare children lists 21787 var childrenMatch = true; 21788 var childNode = elm.firstChild; 21789 for (var i_7 = 0; i_7 < children.length; i_7++) { 21790 if (!childNode || 21791 !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) { 21792 childrenMatch = false; 21793 break; 21794 } 21795 childNode = childNode.nextSibling; 21796 } 21797 // if childNode is not null, it means the actual childNodes list is 21798 // longer than the virtual children list. 21799 if (!childrenMatch || childNode) { 21800 /* istanbul ignore if */ 21801 if (false) {} 21802 return false; 21803 } 21804 } 21805 } 21806 } 21807 if (isDef(data)) { 21808 var fullInvoke = false; 21809 for (var key in data) { 21810 if (!isRenderedModule(key)) { 21811 fullInvoke = true; 21812 invokeCreateHooks(vnode, insertedVnodeQueue); 21813 break; 21814 } 21815 } 21816 if (!fullInvoke && data['class']) { 21817 // ensure collecting deps for deep class bindings for future updates 21818 traverse(data['class']); 21819 } 21820 } 21821 } 21822 else if (elm.data !== vnode.text) { 21823 elm.data = vnode.text; 21824 } 21825 return true; 21826 } 21827 function assertNodeMatch(node, vnode, inVPre) {
21828 if (isDef(vnode.tag)) { 21829 return (vnode.tag.indexOf('vue-component') === 0 || 21830 (!isUnknownElement(vnode, inVPre) && 21831 vnode.tag.toLowerCase() === 21832 (node.tagName && node.tagName.toLowerCase()))); 21833 } 21834 else { 21835 return node.nodeType === (vnode.isComment ? 8 : 3); 21836 } 21837 } 21838 return function patch(oldVnode, vnode, hydrating, removeOnly) { 21839 if (isUndef(vnode)) { 21840 if (isDef(oldVnode)) 21841 invokeDestroyHook(oldVnode); 21842 return; 21843 } 21844 var isInitialPatch = false; 21845 var insertedVnodeQueue = []; 21846 if (isUndef(oldVnode)) { 21847 // empty mount (likely as component), create new root element 21848 isInitialPatch = true; 21849 createElm(vnode, insertedVnodeQueue); 21850 } 21851 else { 21852 var isRealElement = isDef(oldVnode.nodeType); 21853 if (!isRealElement && sameVnode(oldVnode, vnode)) { 21854 // patch existing root node 21855 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly); 21856 } 21857 else { 21858 if (isRealElement) { 21859 // mounting to a real element 21860 // check if this is server-rendered content and if we can perform 21861 // a successful hydration. 21862 if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { 21863 oldVnode.removeAttribute(SSR_ATTR); 21864 hydrating = true; 21865 } 21866 if (isTrue(hydrating)) { 21867 if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { 21868 invokeInsertHook(vnode, insertedVnodeQueue, true); 21869 return oldVnode; 21870 } 21871 else if (false) {} 21872 } 21873 // either not server-rendered, or hydration failed. 21874 // create an empty node and replace it 21875 oldVnode = emptyNodeAt(oldVnode); 21876 } 21877 // replacing existing element 21878 var oldElm = oldVnode.elm; 21879 var parentElm = nodeOps.parentNode(oldElm); 21880 // create new node 21881 createElm(vnode, insertedVnodeQueue, 21882 // extremely rare edge case: do not insert if old element is in a 21883 // leaving transition. Only happens when combining transition + 21884 // keep-alive + HOCs. (#4590) 21885 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm)); 21886 // update parent placeholder node element, recursively
21887 if (isDef(vnode.parent)) { 21888 var ancestor = vnode.parent; 21889 var patchable = isPatchable(vnode); 21890 while (ancestor) { 21891 for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) { 21892 cbs.destroy[i_8](ancestor); 21893 } 21894 ancestor.elm = vnode.elm; 21895 if (patchable) { 21896 for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) { 21897 cbs.create[i_9](emptyNode, ancestor); 21898 } 21899 // #6513 21900 // invoke insert hooks that may have been merged by create hooks. 21901 // e.g. for directives that uses the "inserted" hook. 21902 var insert_1 = ancestor.data.hook.insert; 21903 if (insert_1.merged) { 21904 // start at index 1 to avoid re-invoking component mounted hook 21905 // clone insert hooks to avoid being mutated during iteration. 21906 // e.g. for customed directives under transition group. 21907 var cloned = insert_1.fns.slice(1); 21908 for (var i_10 = 0; i_10 < cloned.length; i_10++) { 21909 cloned[i_10](); 21910 } 21911 } 21912 } 21913 else { 21914 registerRef(ancestor); 21915 } 21916 ancestor = ancestor.parent; 21917 } 21918 } 21919 // destroy old node 21920 if (isDef(parentElm)) { 21921 removeVnodes([oldVnode], 0, 0); 21922 } 21923 else if (isDef(oldVnode.tag)) { 21924 invokeDestroyHook(oldVnode); 21925 } 21926 } 21927 } 21928 invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); 21929 return vnode.elm; 21930 }; 21931} 21932 21933var directives$1 = { 21934 create: updateDirectives, 21935 update: updateDirectives, 21936 destroy: function unbindDirectives(vnode) { 21937 // @ts-expect-error emptyNode is not VNodeWithData 21938 updateDirectives(vnode, emptyNode); 21939 } 21940}; 21941function updateDirectives(oldVnode, vnode) { 21942 if (oldVnode.data.directives || vnode.data.directives) { 21943 _update(oldVnode, vnode); 21944 } 21945} 21946function _update(oldVnode, vnode) { 21947 var isCreate = oldVnode === emptyNode; 21948 var isDestroy = vnode === emptyNode; 21949 var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context); 21950 var newDirs = normalizeDirectives(vnode.data.directives, vnode.context); 21951 var dirsWithInsert = []; 21952 var dirsWithPostpatch = []; 21953 var key, oldDir, dir; 21954 for (key in newDirs) { 21955 oldDir = oldDirs[key]; 21956 dir = newDirs[key]; 21957 if (!oldDir) { 21958 // new directive, bind 21959 callHook(dir, 'bind', vnode, oldVnode); 21960 if (dir.def && dir.def.inserted) { 21961 dirsWithInsert.push(dir); 21962 } 21963 } 21964 else { 21965 // existing directive, update 21966 dir.oldValue = oldDir.value; 21967 dir.oldArg = oldDir.arg; 21968 callHook(dir, 'update', vnode, oldVnode); 21969 if (dir.def && dir.def.componentUpdated) { 21970 dirsWithPostpatch.push(dir); 21971 } 21972 } 21973 } 21974 if (dirsWithInsert.length) { 21975 var callInsert = function () { 21976 for (var i = 0; i < dirsWithInsert.length; i++) { 21977 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode); 21978 } 21979 }; 21980 if (isCreate) { 21981 mergeVNodeHook(vnode, 'insert', callInsert); 21982 } 21983 else { 21984 callInsert(); 21985 } 21986 } 21987 if (dirsWithPostpatch.length) { 21988 mergeVNodeHook(vnode, 'postpatch', function () { 21989 for (var i = 0; i < dirsWithPostpatch.length; i++) { 21990 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); 21991 } 21992 }); 21993 } 21994 if (!isCreate) { 21995 for (key in oldDirs) { 21996 if (!newDirs[key]) { 21997 // no longer present, unbind 21998 callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); 21999 } 22000 } 22001 } 22002} 22003var emptyModifiers = Object.create(null); 22004function normalizeDirectives(dirs, vm) { 22005 var res = Object.create(null); 22006 if (!dirs) { 22007 // $flow-disable-line 22008 return res; 22009 } 22010 var i, dir; 22011 for (i = 0; i < dirs.length; i++) { 22012 dir = dirs[i]; 22013 if (!dir.modifiers) { 22014 // $flow-disable-line 22015 dir.modifiers = emptyModifiers; 22016 } 22017 res[getRawDirName(dir)] = dir; 22018 if (vm._setupState && vm._setupState.__sfc) { 22019 var setupDef = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name); 22020 if (typeof setupDef === 'function') { 22021 dir.def = { 22022 bind: setupDef, 22023 update: setupDef, 22024 }; 22025 } 22026 else { 22027 dir.def = setupDef; 22028 } 22029 } 22030 dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true); 22031 } 22032 // $flow-disable-line 22033 return res; 22034} 22035function getRawDirName(dir) { 22036 return (dir.rawName || "".concat(dir.name, ".").concat(Object.keys(dir.modifiers || {}).join('.'))); 22037} 22038function callHook(dir, hook, vnode, oldVnode, isDestroy) { 22039 var fn = dir.def && dir.def[hook]; 22040 if (fn) { 22041 try { 22042 fn(vnode.elm, dir, vnode, oldVnode, isDestroy); 22043 } 22044 catch (e) { 22045 handleError(e, vnode.context, "directive ".concat(dir.name, " ").concat(hook, " hook")); 22046 } 22047 } 22048} 22049 22050var baseModules = [ref, directives$1]; 22051 22052function updateAttrs(oldVnode, vnode) { 22053 var opts = vnode.componentOptions; 22054 if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { 22055 return; 22056 } 22057 if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { 22058 return; 22059 } 22060 var key, cur, old; 22061 var elm = vnode.elm; 22062 var oldAttrs = oldVnode.data.attrs || {}; 22063 var attrs = vnode.data.attrs || {}; 22064 // clone observed objects, as the user probably wants to mutate it 22065 if (isDef(attrs.__ob__) || isTrue(attrs._v_attr_proxy)) { 22066 attrs = vnode.data.attrs = extend({}, attrs); 22067 } 22068 for (key in attrs) { 22069 cur = attrs[key]; 22070 old = oldAttrs[key]; 22071 if (old !== cur) { 22072 setAttr(elm, key, cur, vnode.data.pre); 22073 } 22074 } 22075 // #4391: in IE9, setting type can reset value for input[type=radio] 22076 // #6666: IE/Edge forces progress value down to 1 before setting a max 22077 /* istanbul ignore if */ 22078 if ((isIE || isEdge) && attrs.value !== oldAttrs.value) { 22079 setAttr(elm, 'value', attrs.value); 22080 } 22081 for (key in oldAttrs) { 22082 if (isUndef(attrs[key])) { 22083 if (isXlink(key)) { 22084 elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); 22085 } 22086 else if (!isEnumeratedAttr(key)) { 22087 elm.removeAttribute(key); 22088 } 22089 } 22090 } 22091} 22092function setAttr(el, key, value, isInPre) { 22093 if (isInPre || el.tagName.indexOf('-') > -1) { 22094 baseSetAttr(el, key, value); 22095 } 22096 else if (isBooleanAttr(key)) { 22097 // set attribute for blank value 22098 // e.g. <option disabled>Select one</option> 22099 if (isFalsyAttrValue(value)) { 22100 el.removeAttribute(key); 22101 } 22102 else { 22103 // technically allowfullscreen is a boolean attribute for <iframe>, 22104 // but Flash expects a value of "true" when used on <embed> tag 22105 value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key; 22106 el.setAttribute(key, value); 22107 } 22108 } 22109 else if (isEnumeratedAttr(key)) { 22110 el.setAttribute(key, convertEnumeratedValue(key, value)); 22111 } 22112 else if (isXlink(key)) { 22113 if (isFalsyAttrValue(value)) { 22114 el.removeAttributeNS(xlinkNS, getXlinkProp(key)); 22115 } 22116 else { 22117 el.setAttributeNS(xlinkNS, key, value); 22118 } 22119 } 22120 else { 22121 baseSetAttr(el, key, value); 22122 } 22123} 22124function baseSetAttr(el, key, value) { 22125 if (isFalsyAttrValue(value)) { 22126 el.removeAttribute(key); 22127 } 22128 else { 22129 // #7138: IE10 & 11 fires input event when setting placeholder on 22130 // <textarea>... block the first input event and remove the blocker 22131 // immediately. 22132 /* istanbul ignore if */ 22133 if (isIE && 22134 !isIE9 && 22135 el.tagName === 'TEXTAREA' && 22136 key === 'placeholder' && 22137 value !== '' && 22138 !el.__ieph) { 22139 var blocker_1 = function (e) { 22140 e.stopImmediatePropagation(); 22141 el.removeEventListener('input', blocker_1); 22142 }; 22143 el.addEventListener('input', blocker_1); 22144 // $flow-disable-line 22145 el.__ieph = true; /* IE placeholder patched */ 22146 } 22147 el.setAttribute(key, value); 22148 } 22149} 22150var attrs = { 22151 create: updateAttrs, 22152 update: updateAttrs 22153}; 22154 22155function updateClass(oldVnode, vnode) { 22156 var el = vnode.elm; 22157 var data = vnode.data; 22158 var oldData = oldVnode.data; 22159 if (isUndef(data.staticClass) && 22160 isUndef(data.class) && 22161 (isUndef(oldData) || 22162 (isUndef(oldData.staticClass) && isUndef(oldData.class)))) { 22163 return; 22164 } 22165 var cls = genClassForVnode(vnode); 22166 // handle transition classes 22167 var transitionClass = el._transitionClasses; 22168 if (isDef(transitionClass)) { 22169 cls = concat(cls, stringifyClass(transitionClass)); 22170 } 22171 // set the class 22172 if (cls !== el._prevClass) { 22173 el.setAttribute('class', cls); 22174 el._prevClass = cls; 22175 } 22176} 22177var klass$1 = { 22178 create: updateClass, 22179 update: updateClass 22180}; 22181 22182var validDivisionCharRE = /[\w).+\-_$\]]/; 22183function parseFilters(exp) { 22184 var inSingle = false;
22185 var inDouble = false; 22186 var inTemplateString = false; 22187 var inRegex = false; 22188 var curly = 0; 22189 var square = 0; 22190 var paren = 0; 22191 var lastFilterIndex = 0; 22192 var c, prev, i, expression, filters; 22193 for (i = 0; i < exp.length; i++) { 22194 prev = c; 22195 c = exp.charCodeAt(i); 22196 if (inSingle) { 22197 if (c === 0x27 && prev !== 0x5c) 22198 inSingle = false; 22199 } 22200 else if (inDouble) { 22201 if (c === 0x22 && prev !== 0x5c) 22202 inDouble = false; 22203 } 22204 else if (inTemplateString) { 22205 if (c === 0x60 && prev !== 0x5c) 22206 inTemplateString = false; 22207 } 22208 else if (inRegex) { 22209 if (c === 0x2f && prev !== 0x5c) 22210 inRegex = false; 22211 } 22212 else if (c === 0x7c && // pipe 22213 exp.charCodeAt(i + 1) !== 0x7c && 22214 exp.charCodeAt(i - 1) !== 0x7c && 22215 !curly && 22216 !square && 22217 !paren) { 22218 if (expression === undefined) { 22219 // first filter, end of expression 22220 lastFilterIndex = i + 1; 22221 expression = exp.slice(0, i).trim(); 22222 } 22223 else { 22224 pushFilter(); 22225 } 22226 } 22227 else { 22228 switch (c) { 22229 case 0x22: 22230 inDouble = true; 22231 break; // " 22232 case 0x27: 22233 inSingle = true; 22234 break; // ' 22235 case 0x60: 22236 inTemplateString = true; 22237 break; // ` 22238 case 0x28: 22239 paren++; 22240 break; // ( 22241 case 0x29: 22242 paren--; 22243 break; // ) 22244 case 0x5b: 22245 square++; 22246 break; // [ 22247 case 0x5d: 22248 square--; 22249 break; // ] 22250 case 0x7b: 22251 curly++; 22252 break; // { 22253 case 0x7d: 22254 curly--; 22255 break; // } 22256 } 22257 if (c === 0x2f) { 22258 // / 22259 var j = i - 1; 22260 var p 22261 // find first non-whitespace prev char 22262 = void 0; 22263 // find first non-whitespace prev char 22264 for (; j >= 0; j--) { 22265 p = exp.charAt(j); 22266 if (p !== ' ') 22267 break; 22268 } 22269 if (!p || !validDivisionCharRE.test(p)) { 22270 inRegex = true; 22271 } 22272 } 22273 } 22274 } 22275 if (expression === undefined) { 22276 expression = exp.slice(0, i).trim(); 22277 } 22278 else if (lastFilterIndex !== 0) { 22279 pushFilter(); 22280 } 22281 function pushFilter() { 22282 (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); 22283 lastFilterIndex = i + 1; 22284 } 22285 if (filters) { 22286 for (i = 0; i < filters.length; i++) { 22287 expression = wrapFilter(expression, filters[i]); 22288 } 22289 } 22290 return expression; 22291} 22292function wrapFilter(exp, filter) { 22293 var i = filter.indexOf('('); 22294 if (i < 0) { 22295 // _f: resolveFilter 22296 return "_f(\"".concat(filter, "\")(").concat(exp, ")"); 22297 } 22298 else { 22299 var name_1 = filter.slice(0, i); 22300 var args = filter.slice(i + 1); 22301 return "_f(\"".concat(name_1, "\")(").concat(exp).concat(args !== ')' ? ',' + args : args); 22302 } 22303} 22304 22305/* eslint-disable no-unused-vars */ 22306function baseWarn(msg, range) { 22307 console.error("[Vue compiler]: ".concat(msg)); 22308} 22309/* eslint-enable no-unused-vars */ 22310function pluckModuleFunction(modules, key) { 22311 return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : []; 22312} 22313function addProp(el, name, value, range, dynamic) { 22314 (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)); 22315 el.plain = false; 22316} 22317function addAttr(el, name, value, range, dynamic) { 22318 var attrs = dynamic 22319 ? el.dynamicAttrs || (el.dynamicAttrs = []) 22320 : el.attrs || (el.attrs = []); 22321 attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)); 22322 el.plain = false;
22323} 22324// add a raw attr (use this in preTransforms) 22325function addRawAttr(el, name, value, range) { 22326 el.attrsMap[name] = value; 22327 el.attrsList.push(rangeSetItem({ name: name, value: value }, range)); 22328} 22329function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) { 22330 (el.directives || (el.directives = [])).push(rangeSetItem({ 22331 name: name, 22332 rawName: rawName, 22333 value: value, 22334 arg: arg, 22335 isDynamicArg: isDynamicArg, 22336 modifiers: modifiers 22337 }, range)); 22338 el.plain = false; 22339} 22340function prependModifierMarker(symbol, name, dynamic) { 22341 return dynamic ? "_p(".concat(name, ",\"").concat(symbol, "\")") : symbol + name; // mark the event as captured 22342} 22343function addHandler(el, name, value, modifiers, important, warn, range, dynamic) { 22344 modifiers = modifiers || emptyObject; 22345 // warn prevent and passive modifier 22346 /* istanbul ignore if */ 22347 if (false) {} 22348 // normalize click.right and click.middle since they don't actually fire 22349 // this is technically browser-specific, but at least for now browsers are 22350 // the only target envs that have right/middle clicks. 22351 if (modifiers.right) { 22352 if (dynamic) { 22353 name = "(".concat(name, ")==='click'?'contextmenu':(").concat(name, ")"); 22354 } 22355 else if (name === 'click') { 22356 name = 'contextmenu'; 22357 delete modifiers.right; 22358 } 22359 } 22360 else if (modifiers.middle) { 22361 if (dynamic) { 22362 name = "(".concat(name, ")==='click'?'mouseup':(").concat(name, ")"); 22363 } 22364 else if (name === 'click') { 22365 name = 'mouseup'; 22366 } 22367 } 22368 // check capture modifier 22369 if (modifiers.capture) { 22370 delete modifiers.capture; 22371 name = prependModifierMarker('!', name, dynamic); 22372 } 22373 if (modifiers.once) { 22374 delete modifiers.once; 22375 name = prependModifierMarker('~', name, dynamic); 22376 } 22377 /* istanbul ignore if */ 22378 if (modifiers.passive) { 22379 delete modifiers.passive; 22380 name = prependModifierMarker('&', name, dynamic); 22381 } 22382 var events; 22383 if (modifiers.native) { 22384 delete modifiers.native; 22385 events = el.nativeEvents || (el.nativeEvents = {}); 22386 } 22387 else { 22388 events = el.events || (el.events = {}); 22389 } 22390 var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range); 22391 if (modifiers !== emptyObject) { 22392 newHandler.modifiers = modifiers; 22393 } 22394 var handlers = events[name]; 22395 /* istanbul ignore if */ 22396 if (Array.isArray(handlers)) { 22397 important ? handlers.unshift(newHandler) : handlers.push(newHandler); 22398 } 22399 else if (handlers) { 22400 events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; 22401 } 22402 else { 22403 events[name] = newHandler; 22404 } 22405 el.plain = false; 22406} 22407function getRawBindingAttr(el, name) { 22408 return (el.rawAttrsMap[':' + name] || 22409 el.rawAttrsMap['v-bind:' + name] || 22410 el.rawAttrsMap[name]); 22411} 22412function getBindingAttr(el, name, getStatic) { 22413 var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name); 22414 if (dynamicValue != null) { 22415 return parseFilters(dynamicValue); 22416 } 22417 else if (getStatic !== false) { 22418 var staticValue = getAndRemoveAttr(el, name); 22419 if (staticValue != null) { 22420 return JSON.stringify(staticValue); 22421 } 22422 } 22423} 22424// note: this only removes the attr from the Array (attrsList) so that it 22425// doesn't get processed by processAttrs. 22426// By default it does NOT remove it from the map (attrsMap) because the map is 22427// needed during codegen. 22428function getAndRemoveAttr(el, name, removeFromMap) { 22429 var val; 22430 if ((val = el.attrsMap[name]) != null) { 22431 var list = el.attrsList; 22432 for (var i = 0, l = list.length; i < l; i++) { 22433 if (list[i].name === name) { 22434 list.splice(i, 1); 22435 break; 22436 } 22437 } 22438 } 22439 if (removeFromMap) { 22440 delete el.attrsMap[name]; 22441 } 22442 return val; 22443} 22444function getAndRemoveAttrByRegex(el, name) { 22445 var list = el.attrsList; 22446 for (var i = 0, l = list.length; i < l; i++) { 22447 var attr = list[i]; 22448 if (name.test(attr.name)) { 22449 list.splice(i, 1); 22450 return attr; 22451 } 22452 } 22453} 22454function rangeSetItem(item, range) { 22455 if (range) { 22456 if (range.start != null) { 22457 item.start = range.start; 22458 } 22459 if (range.end != null) { 22460 item.end = range.end; 22461 } 22462 } 22463 return item; 22464} 22465 22466/** 22467 * Cross-platform code generation for component v-model 22468 */ 22469function genComponentModel(el, value, modifiers) { 22470 var _a = modifiers || {}, number = _a.number, trim = _a.trim; 22471 var baseValueExpression = '$$v'; 22472 var valueExpression = baseValueExpression; 22473 if (trim) { 22474 valueExpression = 22475 "(typeof ".concat(baseValueExpression, " === 'string'") + 22476 "? ".concat(baseValueExpression, ".trim()") + 22477 ": ".concat(baseValueExpression, ")"); 22478 } 22479 if (number) { 22480 valueExpression = "_n(".concat(valueExpression, ")"); 22481 }
22482 var assignment = genAssignmentCode(value, valueExpression); 22483 el.model = { 22484 value: "(".concat(value, ")"), 22485 expression: JSON.stringify(value), 22486 callback: "function (".concat(baseValueExpression, ") {").concat(assignment, "}") 22487 }; 22488} 22489/** 22490 * Cross-platform codegen helper for generating v-model value assignment code. 22491 */ 22492function genAssignmentCode(value, assignment) { 22493 var res = parseModel(value); 22494 if (res.key === null) { 22495 return "".concat(value, "=").concat(assignment); 22496 } 22497 else { 22498 return "$set(".concat(res.exp, ", ").concat(res.key, ", ").concat(assignment, ")"); 22499 } 22500} 22501/** 22502 * Parse a v-model expression into a base path and a final key segment. 22503 * Handles both dot-path and possible square brackets. 22504 * 22505 * Possible cases: 22506 * 22507 * - test 22508 * - test[key] 22509 * - test[test1[key]] 22510 * - test["a"][key] 22511 * - xxx.test[a[a].test1[key]] 22512 * - test.xxx.a["asa"][test1[key]] 22513 * 22514 */ 22515var len, str, chr, index, expressionPos, expressionEndPos; 22516function parseModel(val) { 22517 // Fix https://github.com/vuejs/vue/pull/7730 22518 // allow v-model="obj.val " (trailing whitespace) 22519 val = val.trim(); 22520 len = val.length; 22521 if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { 22522 index = val.lastIndexOf('.'); 22523 if (index > -1) { 22524 return { 22525 exp: val.slice(0, index), 22526 key: '"' + val.slice(index + 1) + '"' 22527 }; 22528 } 22529 else { 22530 return { 22531 exp: val, 22532 key: null 22533 }; 22534 } 22535 } 22536 str = val; 22537 index = expressionPos = expressionEndPos = 0; 22538 while (!eof()) { 22539 chr = next(); 22540 /* istanbul ignore if */ 22541 if (isStringStart(chr)) { 22542 parseString(chr); 22543 } 22544 else if (chr === 0x5b) { 22545 parseBracket(chr); 22546 } 22547 } 22548 return { 22549 exp: val.slice(0, expressionPos), 22550 key: val.slice(expressionPos + 1, expressionEndPos) 22551 }; 22552} 22553function next() { 22554 return str.charCodeAt(++index); 22555} 22556function eof() { 22557 return index >= len; 22558} 22559function isStringStart(chr) { 22560 return chr === 0x22 || chr === 0x27; 22561} 22562function parseBracket(chr) { 22563 var inBracket = 1; 22564 expressionPos = index; 22565 while (!eof()) { 22566 chr = next(); 22567 if (isStringStart(chr)) { 22568 parseString(chr); 22569 continue; 22570 } 22571 if (chr === 0x5b) 22572 inBracket++; 22573 if (chr === 0x5d) 22574 inBracket--; 22575 if (inBracket === 0) { 22576 expressionEndPos = index; 22577 break; 22578 } 22579 } 22580} 22581function parseString(chr) { 22582 var stringQuote = chr; 22583 while (!eof()) { 22584 chr = next(); 22585 if (chr === stringQuote) { 22586 break; 22587 } 22588 } 22589} 22590 22591var warn$1; 22592// in some cases, the event used has to be determined at runtime 22593// so we used some reserved tokens during compile. 22594var RANGE_TOKEN = '__r'; 22595var CHECKBOX_RADIO_TOKEN = '__c'; 22596function model$1(el, dir, _warn) { 22597 warn$1 = _warn; 22598 var value = dir.value; 22599 var modifiers = dir.modifiers; 22600 var tag = el.tag; 22601 var type = el.attrsMap.type; 22602 if (false) {} 22603 if (el.component) { 22604 genComponentModel(el, value, modifiers); 22605 // component v-model doesn't need extra runtime 22606 return false; 22607 } 22608 else if (tag === 'select') { 22609 genSelect(el, value, modifiers); 22610 } 22611 else if (tag === 'input' && type === 'checkbox') { 22612 genCheckboxModel(el, value, modifiers); 22613 } 22614 else if (tag === 'input' && type === 'radio') { 22615 genRadioModel(el, value, modifiers); 22616 } 22617 else if (tag === 'input' || tag === 'textarea') { 22618 genDefaultModel(el, value, modifiers); 22619 } 22620 else if (!config.isReservedTag(tag)) { 22621 genComponentModel(el, value, modifiers); 22622 // component v-model doesn't need extra runtime 22623 return false; 22624 } 22625 else if (false) {} 22626 // ensure runtime directive metadata 22627 return true; 22628} 22629function genCheckboxModel(el, value, modifiers) { 22630 var number = modifiers && modifiers.number; 22631 var valueBinding = getBindingAttr(el, 'value') || 'null'; 22632 var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; 22633 var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; 22634 addProp(el, 'checked', "Array.isArray(".concat(value, ")") + 22635 "?_i(".concat(value, ",").concat(valueBinding, ")>-1") + 22636 (trueValueBinding === 'true' 22637 ? ":(".concat(value, ")") 22638 : ":_q(".concat(value, ",").concat(trueValueBinding, ")"))); 22639 addHandler(el, 'change', "var $$a=".concat(value, ",") + 22640 '$$el=$event.target,' + 22641 "$$c=$$el.checked?(".concat(trueValueBinding, "):(").concat(falseValueBinding, ");") + 22642 'if(Array.isArray($$a)){' + 22643 "var $$v=".concat(number ? '_n(' + valueBinding + ')' : valueBinding, ",") + 22644 '$$i=_i($$a,$$v);' +
22645 "if($$el.checked){$$i<0&&(".concat(genAssignmentCode(value, '$$a.concat([$$v])'), ")}") + 22646 "else{$$i>-1&&(".concat(genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))'), ")}") + 22647 "}else{".concat(genAssignmentCode(value, '$$c'), "}"), null, true); 22648} 22649function genRadioModel(el, value, modifiers) { 22650 var number = modifiers && modifiers.number; 22651 var valueBinding = getBindingAttr(el, 'value') || 'null'; 22652 valueBinding = number ? "_n(".concat(valueBinding, ")") : valueBinding; 22653 addProp(el, 'checked', "_q(".concat(value, ",").concat(valueBinding, ")")); 22654 addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); 22655} 22656function genSelect(el, value, modifiers) { 22657 var number = modifiers && modifiers.number; 22658 var selectedVal = "Array.prototype.filter" + 22659 ".call($event.target.options,function(o){return o.selected})" + 22660 ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" + 22661 "return ".concat(number ? '_n(val)' : 'val', "})"); 22662 var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; 22663 var code = "var $$selectedVal = ".concat(selectedVal, ";"); 22664 code = "".concat(code, " ").concat(genAssignmentCode(value, assignment)); 22665 addHandler(el, 'change', code, null, true); 22666} 22667function genDefaultModel(el, value, modifiers) { 22668 var type = el.attrsMap.type; 22669 // warn if v-bind:value conflicts with v-model 22670 // except for inputs with v-bind:type 22671 if (false) { var binding, typeBinding, value_1; } 22672 var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim; 22673 var needCompositionGuard = !lazy && type !== 'range'; 22674 var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'; 22675 var valueExpression = '$event.target.value'; 22676 if (trim) { 22677 valueExpression = "$event.target.value.trim()"; 22678 } 22679 if (number) { 22680 valueExpression = "_n(".concat(valueExpression, ")"); 22681 } 22682 var code = genAssignmentCode(value, valueExpression); 22683 if (needCompositionGuard) { 22684 code = "if($event.target.composing)return;".concat(code); 22685 } 22686 addProp(el, 'value', "(".concat(value, ")")); 22687 addHandler(el, event, code, null, true); 22688 if (trim || number) { 22689 addHandler(el, 'blur', '$forceUpdate()'); 22690 } 22691} 22692 22693// normalize v-model event tokens that can only be determined at runtime. 22694// it's important to place the event as the first in the array because 22695// the whole point is ensuring the v-model callback gets called before 22696// user-attached handlers. 22697function normalizeEvents(on) { 22698 /* istanbul ignore if */ 22699 if (isDef(on[RANGE_TOKEN])) { 22700 // IE input[type=range] only supports `change` event 22701 var event_1 = isIE ? 'change' : 'input'; 22702 on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []); 22703 delete on[RANGE_TOKEN]; 22704 } 22705 // This was originally intended to fix #4521 but no longer necessary 22706 // after 2.5. Keeping it for backwards compat with generated code from < 2.4 22707 /* istanbul ignore if */ 22708 if (isDef(on[CHECKBOX_RADIO_TOKEN])) { 22709 on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []); 22710 delete on[CHECKBOX_RADIO_TOKEN]; 22711 } 22712} 22713var target; 22714function createOnceHandler(event, handler, capture) { 22715 var _target = target; // save current target element in closure 22716 return function onceHandler() { 22717 var res = handler.apply(null, arguments); 22718 if (res !== null) { 22719 remove(event, onceHandler, capture, _target); 22720 } 22721 }; 22722} 22723// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp 22724// implementation and does not fire microtasks in between event propagation, so 22725// safe to exclude. 22726var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53); 22727function add(name, handler, capture, passive) { 22728 // async edge case #6566: inner click event triggers patch, event handler 22729 // attached to outer element during patch, and triggered again. This 22730 // happens because browsers fire microtask ticks between event propagation. 22731 // the solution is simple: we save the timestamp when a handler is attached, 22732 // and the handler would only fire if the event passed to it was fired 22733 // AFTER it was attached.
22734 if (useMicrotaskFix) { 22735 var attachedTimestamp_1 = currentFlushTimestamp; 22736 var original_1 = handler; 22737 //@ts-expect-error 22738 handler = original_1._wrapper = function (e) { 22739 if ( 22740 // no bubbling, should always fire. 22741 // this is just a safety net in case event.timeStamp is unreliable in 22742 // certain weird environments... 22743 e.target === e.currentTarget || 22744 // event is fired after handler attachment 22745 e.timeStamp >= attachedTimestamp_1 || 22746 // bail for environments that have buggy event.timeStamp implementations 22747 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState 22748 // #9681 QtWebEngine event.timeStamp is negative value 22749 e.timeStamp <= 0 || 22750 // #9448 bail if event is fired in another document in a multi-page 22751 // electron/nw.js app, since event.timeStamp will be using a different 22752 // starting reference 22753 e.target.ownerDocument !== document) { 22754 return original_1.apply(this, arguments); 22755 } 22756 }; 22757 } 22758 target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture); 22759} 22760function remove(name, handler, capture, _target) { 22761 (_target || target).removeEventListener(name, 22762 //@ts-expect-error 22763 handler._wrapper || handler, capture); 22764} 22765function updateDOMListeners(oldVnode, vnode) { 22766 if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { 22767 return; 22768 } 22769 var on = vnode.data.on || {}; 22770 var oldOn = oldVnode.data.on || {}; 22771 // vnode is empty when removing all listeners, 22772 // and use old vnode dom element 22773 target = vnode.elm || oldVnode.elm; 22774 normalizeEvents(on); 22775 updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context); 22776 target = undefined; 22777} 22778var events = { 22779 create: updateDOMListeners, 22780 update: updateDOMListeners, 22781 // @ts-expect-error emptyNode has actually data 22782 destroy: function (vnode) { return updateDOMListeners(vnode, emptyNode); } 22783}; 22784 22785var svgContainer; 22786function updateDOMProps(oldVnode, vnode) { 22787 if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { 22788 return; 22789 } 22790 var key, cur; 22791 var elm = vnode.elm; 22792 var oldProps = oldVnode.data.domProps || {}; 22793 var props = vnode.data.domProps || {}; 22794 // clone observed objects, as the user probably wants to mutate it 22795 if (isDef(props.__ob__) || isTrue(props._v_attr_proxy)) { 22796 props = vnode.data.domProps = extend({}, props); 22797 } 22798 for (key in oldProps) { 22799 if (!(key in props)) { 22800 elm[key] = ''; 22801 } 22802 } 22803 for (key in props) { 22804 cur = props[key]; 22805 // ignore children if the node has textContent or innerHTML, 22806 // as these will throw away existing DOM nodes and cause removal errors 22807 // on subsequent patches (#3360) 22808 if (key === 'textContent' || key === 'innerHTML') { 22809 if (vnode.children) 22810 vnode.children.length = 0; 22811 if (cur === oldProps[key]) 22812 continue; 22813 // #6601 work around Chrome version <= 55 bug where single textNode 22814 // replaced by innerHTML/textContent retains its parentNode property 22815 if (elm.childNodes.length === 1) { 22816 elm.removeChild(elm.childNodes[0]); 22817 } 22818 } 22819 if (key === 'value' && elm.tagName !== 'PROGRESS') { 22820 // store value as _value as well since 22821 // non-string values will be stringified 22822 elm._value = cur; 22823 // avoid resetting cursor position when value is the same 22824 var strCur = isUndef(cur) ? '' : String(cur); 22825 if (shouldUpdateValue(elm, strCur)) { 22826 elm.value = strCur; 22827 } 22828 } 22829 else if (key === 'innerHTML' && 22830 isSVG(elm.tagName) && 22831 isUndef(elm.innerHTML)) { 22832 // IE doesn't support innerHTML for SVG elements 22833 svgContainer = svgContainer || document.createElement('div'); 22834 svgContainer.innerHTML = "<svg>".concat(cur, "</svg>"); 22835 var svg = svgContainer.firstChild; 22836 while (elm.firstChild) { 22837 elm.removeChild(elm.firstChild); 22838 } 22839 while (svg.firstChild) { 22840 elm.appendChild(svg.firstChild); 22841 } 22842 } 22843 else if ( 22844 // skip the update if old and new VDOM state is the same. 22845 // `value` is handled separately because the DOM value may be temporarily 22846 // out of sync with VDOM state due to focus, composition and modifiers. 22847 // This #4521 by skipping the unnecessary `checked` update. 22848 cur !== oldProps[key]) { 22849 // some property updates can throw 22850 // e.g. `value` on <progress> w/ non-finite value 22851 try { 22852 elm[key] = cur; 22853 } 22854 catch (e) { } 22855 } 22856 } 22857} 22858function shouldUpdateValue(elm, checkVal) { 22859 return ( 22860 //@ts-expect-error 22861 !elm.composing && 22862 (elm.tagName === 'OPTION' || 22863 isNotInFocusAndDirty(elm, checkVal) || 22864 isDirtyWithModifiers(elm, checkVal))); 22865} 22866function isNotInFocusAndDirty(elm, checkVal) { 22867 // return true when textbox (.number and .trim) loses focus and its value is 22868 // not equal to the updated value 22869 var notInFocus = true; 22870 // #6157 22871 // work around IE bug when accessing document.activeElement in an iframe 22872 try { 22873 notInFocus = document.activeElement !== elm; 22874 } 22875 catch (e) { } 22876 return notInFocus && elm.value !== checkVal; 22877} 22878function isDirtyWithModifiers(elm, newVal) { 22879 var value = elm.value; 22880 var modifiers = elm._vModifiers; // injected by v-model runtime 22881 if (isDef(modifiers)) { 22882 if (modifiers.number) { 22883 return toNumber(value) !== toNumber(newVal); 22884 } 22885 if (modifiers.trim) { 22886 return value.trim() !== newVal.trim(); 22887 } 22888 } 22889 return value !== newVal; 22890} 22891var domProps = { 22892 create: updateDOMProps, 22893 update: updateDOMProps 22894}; 22895 22896var parseStyleText = cached(function (cssText) { 22897 var res = {}; 22898 var listDelimiter = /;(?![^(]*\))/g; 22899 var propertyDelimiter = /:(.+)/; 22900 cssText.split(listDelimiter).forEach(function (item) { 22901 if (item) { 22902 var tmp = item.split(propertyDelimiter); 22903 tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); 22904 } 22905 }); 22906 return res; 22907}); 22908// merge static and dynamic style data on the same vnode 22909function normalizeStyleData(data) { 22910 var style = normalizeStyleBinding(data.style); 22911 // static style is pre-processed into an object during compilation 22912 // and is always a fresh object, so it's safe to merge into
22912it 22913 return data.staticStyle ? extend(data.staticStyle, style) : style; 22914} 22915// normalize possible array / string values into Object 22916function normalizeStyleBinding(bindingStyle) { 22917 if (Array.isArray(bindingStyle)) { 22918 return toObject(bindingStyle); 22919 } 22920 if (typeof bindingStyle === 'string') { 22921 return parseStyleText(bindingStyle); 22922 } 22923 return bindingStyle; 22924} 22925/** 22926 * parent component style should be after child's 22927 * so that parent component's style could override it 22928 */ 22929function getStyle(vnode, checkChild) { 22930 var res = {}; 22931 var styleData; 22932 if (checkChild) { 22933 var childNode = vnode; 22934 while (childNode.componentInstance) { 22935 childNode = childNode.componentInstance._vnode; 22936 if (childNode && 22937 childNode.data && 22938 (styleData = normalizeStyleData(childNode.data))) { 22939 extend(res, styleData); 22940 } 22941 } 22942 } 22943 if ((styleData = normalizeStyleData(vnode.data))) { 22944 extend(res, styleData); 22945 } 22946 var parentNode = vnode; 22947 // @ts-expect-error parentNode.parent not VNodeWithData 22948 while ((parentNode = parentNode.parent)) { 22949 if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { 22950 extend(res, styleData); 22951 } 22952 } 22953 return res; 22954} 22955 22956var cssVarRE = /^--/; 22957var importantRE = /\s*!important$/; 22958var setProp = function (el, name, val) { 22959 /* istanbul ignore if */ 22960 if (cssVarRE.test(name)) { 22961 el.style.setProperty(name, val); 22962 } 22963 else if (importantRE.test(val)) { 22964 el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important'); 22965 } 22966 else { 22967 var normalizedName = normalize(name); 22968 if (Array.isArray(val)) { 22969 // Support values array created by autoprefixer, e.g. 22970 // {display: ["-webkit-box", "-ms-flexbox", "flex"]} 22971 // Set them one by one, and the browser will only set those it can recognize 22972 for (var i = 0, len = val.length; i < len; i++) { 22973 el.style[normalizedName] = val[i]; 22974 } 22975 } 22976 else { 22977 el.style[normalizedName] = val; 22978 } 22979 } 22980}; 22981var vendorNames = ['Webkit', 'Moz', 'ms']; 22982var emptyStyle; 22983var normalize = cached(function (prop) { 22984 emptyStyle = emptyStyle || document.createElement('div').style; 22985 prop = camelize(prop); 22986 if (prop !== 'filter' && prop in emptyStyle) { 22987 return prop; 22988 } 22989 var capName = prop.charAt(0).toUpperCase() + prop.slice(1); 22990 for (var i = 0; i < vendorNames.length; i++) { 22991 var name_1 = vendorNames[i] + capName; 22992 if (name_1 in emptyStyle) { 22993 return name_1; 22994 } 22995 } 22996}); 22997function updateStyle(oldVnode, vnode) { 22998 var data = vnode.data; 22999 var oldData = oldVnode.data; 23000 if (isUndef(data.staticStyle) && 23001 isUndef(data.style) && 23002 isUndef(oldData.staticStyle) && 23003 isUndef(oldData.style)) { 23004 return; 23005 } 23006 var cur, name; 23007 var el = vnode.elm; 23008 var oldStaticStyle = oldData.staticStyle; 23009 var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; 23010 // if static style exists, stylebinding already merged into it when doing normalizeStyleData 23011 var oldStyle = oldStaticStyle || oldStyleBinding; 23012 var style = normalizeStyleBinding(vnode.data.style) || {}; 23013 // store normalized style under a different key for next diff 23014 // make sure to clone it if it's reactive, since the user likely wants 23015 // to mutate it. 23016 vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style; 23017 var newStyle = getStyle(vnode, true); 23018 for (name in oldStyle) { 23019 if (isUndef(newStyle[name])) { 23020 setProp(el, name, ''); 23021 } 23022 } 23023 for (name in newStyle) { 23024 cur = newStyle[name]; 23025 // ie9 setting to null has no effect, must use empty string 23026 setProp(el, name, cur == null ? '' : cur); 23027 } 23028} 23029var style$1 = { 23030 create: updateStyle, 23031 update: updateStyle 23032}; 23033 23034var whitespaceRE$1 = /\s+/; 23035/** 23036 * Add class with compatibility for SVG since classList is not supported on 23037 * SVG elements in IE 23038 */ 23039function addClass(el, cls) { 23040 /* istanbul ignore if */ 23041 if (!cls || !(cls = cls.trim())) { 23042 return; 23043 } 23044 /* istanbul ignore else */ 23045 if (el.classList) { 23046 if (cls.indexOf(' ') > -1) {
23047 cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); }); 23048 } 23049 else { 23050 el.classList.add(cls); 23051 } 23052 } 23053 else { 23054 var cur = " ".concat(el.getAttribute('class') || '', " "); 23055 if (cur.indexOf(' ' + cls + ' ') < 0) { 23056 el.setAttribute('class', (cur + cls).trim()); 23057 } 23058 } 23059} 23060/** 23061 * Remove class with compatibility for SVG since classList is not supported on 23062 * SVG elements in IE 23063 */ 23064function removeClass(el, cls) { 23065 /* istanbul ignore if */ 23066 if (!cls || !(cls = cls.trim())) { 23067 return; 23068 } 23069 /* istanbul ignore else */ 23070 if (el.classList) { 23071 if (cls.indexOf(' ') > -1) { 23072 cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); }); 23073 } 23074 else { 23075 el.classList.remove(cls); 23076 } 23077 if (!el.classList.length) { 23078 el.removeAttribute('class'); 23079 } 23080 } 23081 else { 23082 var cur = " ".concat(el.getAttribute('class') || '', " "); 23083 var tar = ' ' + cls + ' '; 23084 while (cur.indexOf(tar) >= 0) { 23085 cur = cur.replace(tar, ' '); 23086 } 23087 cur = cur.trim(); 23088 if (cur) { 23089 el.setAttribute('class', cur); 23090 } 23091 else { 23092 el.removeAttribute('class'); 23093 } 23094 } 23095} 23096 23097function resolveTransition(def) { 23098 if (!def) { 23099 return; 23100 } 23101 /* istanbul ignore else */ 23102 if (typeof def === 'object') { 23103 var res = {}; 23104 if (def.css !== false) { 23105 extend(res, autoCssTransition(def.name || 'v')); 23106 } 23107 extend(res, def); 23108 return res; 23109 } 23110 else if (typeof def === 'string') { 23111 return autoCssTransition(def); 23112 } 23113} 23114var autoCssTransition = cached(function (name) { 23115 return { 23116 enterClass: "".concat(name, "-enter"), 23117 enterToClass: "".concat(name, "-enter-to"), 23118 enterActiveClass: "".concat(name, "-enter-active"), 23119 leaveClass: "".concat(name, "-leave"), 23120 leaveToClass: "".concat(name, "-leave-to"), 23121 leaveActiveClass: "".concat(name, "-leave-active") 23122 }; 23123}); 23124var hasTransition = inBrowser && !isIE9; 23125var TRANSITION = 'transition'; 23126var ANIMATION = 'animation'; 23127// Transition property/event sniffing 23128var transitionProp = 'transition'; 23129var transitionEndEvent = 'transitionend'; 23130var animationProp = 'animation'; 23131var animationEndEvent = 'animationend'; 23132if (hasTransition) { 23133 /* istanbul ignore if */ 23134 if (window.ontransitionend === undefined && 23135 window.onwebkittransitionend !== undefined) { 23136 transitionProp = 'WebkitTransition'; 23137 transitionEndEvent = 'webkitTransitionEnd'; 23138 } 23139 if (window.onanimationend === undefined && 23140 window.onwebkitanimationend !== undefined) { 23141 animationProp = 'WebkitAnimation'; 23142 animationEndEvent = 'webkitAnimationEnd'; 23143 } 23144} 23145// binding to window is necessary to make hot reload work in IE in strict mode 23146var raf = inBrowser 23147 ? window.requestAnimationFrame 23148 ? window.requestAnimationFrame.bind(window) 23149 : setTimeout 23150 : /* istanbul ignore next */ function (/* istanbul ignore next */ fn) { return fn(); }; 23151function nextFrame(fn) { 23152 raf(function () { 23153 // @ts-expect-error 23154 raf(fn); 23155 }); 23156} 23157function addTransitionClass(el, cls) { 23158 var transitionClasses = el._transitionClasses || (el._transitionClasses = []); 23159 if (transitionClasses.indexOf(cls) < 0) { 23160 transitionClasses.push(cls); 23161 addClass(el, cls); 23162 } 23163} 23164function removeTransitionClass(el, cls) { 23165 if (el._transitionClasses) { 23166 remove$2(el._transitionClasses, cls); 23167 } 23168 removeClass(el, cls); 23169} 23170function whenTransitionEnds(el, expectedType, cb) { 23171 var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount; 23172 if (!type) 23173 return cb(); 23174 var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; 23175 var ended = 0; 23176 var end = function () { 23177 el.removeEventListener(event, onEnd); 23178 cb(); 23179 }; 23180 var onEnd = function (e) { 23181 if (e.target === el) { 23182 if (++ended >= propCount) { 23183 end(); 23184 } 23185 } 23186 }; 23187 setTimeout(function () { 23188 if (ended < propCount) { 23189 end(); 23190 } 23191 }, timeout + 1); 23192 el.addEventListener(event, onEnd); 23193} 23194var transformRE = /\b(transform|all)(,|$)/; 23195function getTransitionInfo(el, expectedType) { 23196 var styles = window.getComputedStyle(el); 23197 // JSDOM may return undefined for transition properties 23198 var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', '); 23199 var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', '); 23200 var transitionTimeout = getTimeout(transitionDelays, transitionDurations); 23201 var animationDelays = (styles[animationProp + 'Delay'] || '').split(', '); 23202 var animationDurations = (styles[animationProp + 'Duration'] || '').split(', '); 23203 var animationTimeout = getTimeout(animationDelays, animationDurations); 23204 var type; 23205 var timeout = 0; 23206 var propCount = 0; 23207 /* istanbul ignore if */ 23208 if (expectedType === TRANSITION) { 23209 if (transitionTimeout > 0) { 23210 type = TRANSITION; 23211 timeout = transitionTimeout; 23212 propCount = transitionDurations.length; 23213 } 23214 } 23215 else if (expectedType === ANIMATION) { 23216 if (animationTimeout > 0) { 23217 type = ANIMATION; 23218 timeout = animationTimeout; 23219 propCount = animationDurations.length; 23220 } 23221 } 23222 else { 23223 timeout = Math.max(transitionTimeout, animationTimeout); 23224 type = 23225 timeout > 0 23226 ? transitionTimeout > animationTimeout 23227 ? TRANSITION 23228 : ANIMATION 23229 : null; 23230 propCount = type 23231 ? type === TRANSITION 23232 ? transitionDurations.length 23233 : animationDurations.length 23234 : 0; 23235 } 23236 var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']); 23237 return { 23238 type: type, 23239 timeout: timeout, 23240 propCount: propCount, 23241 hasTransform: hasTransform 23242 }; 23243} 23244function getTimeout(delays, durations) { 23245 /* istanbul ignore next */ 23246 while (delays.length < durations.length) { 23247 delays = delays.concat(delays); 23248 } 23249 return Math.max.apply(null, durations.map(function (d, i) { 23250 return toMs(d) + toMs(delays[i]); 23251 })); 23252} 23253// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers 23254// in a locale-dependent way, using a comma instead of a dot. 23255// If comma is not replaced with a dot, the input will be rounded down (i.e. acting 23256// as a floor function) causing unexpected behaviors 23257function toMs(s) { 23258 return Number(s.slice(0, -1).replace(',', '.')) * 1000; 23259} 23260 23261function enter(vnode, toggleDisplay) { 23262 var el = vnode.elm; 23263 // call leave callback now 23264 if (isDef(el._leaveCb)) { 23265 el._leaveCb.cancelled = true; 23266 el._leaveCb(); 23267 } 23268 var data = resolveTransition(vnode.data.transition); 23269 if (isUndef(data)) { 23270 return; 23271 } 23272 /* istanbul ignore if */ 23273 if (isDef(el._enterCb) || el.nodeType !== 1) { 23274 return; 23275 } 23276 var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, after
23276Enter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration; 23277 // activeInstance will always be the <transition> component managing this 23278 // transition. One edge case to check is when the <transition> is placed 23279 // as the root node of a child component. In that case we need to check 23280 // <transition>'s parent for appear check. 23281 var context = activeInstance; 23282 var transitionNode = activeInstance.$vnode; 23283 while (transitionNode && transitionNode.parent) { 23284 context = transitionNode.context; 23285 transitionNode = transitionNode.parent; 23286 } 23287 var isAppear = !context._isMounted || !vnode.isRootInsert; 23288 if (isAppear && !appear && appear !== '') { 23289 return; 23290 } 23291 var startClass = isAppear && appearClass ? appearClass : enterClass; 23292 var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass; 23293 var toClass = isAppear && appearToClass ? appearToClass : enterToClass; 23294 var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter; 23295 var enterHook = isAppear ? (isFunction(appear) ? appear : enter) : enter; 23296 var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter; 23297 var enterCancelledHook = isAppear 23298 ? appearCancelled || enterCancelled 23299 : enterCancelled; 23300 var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration); 23301 if (false) {} 23302 var expectsCSS = css !== false && !isIE9; 23303 var userWantsControl = getHookArgumentsLength(enterHook); 23304 var cb = (el._enterCb = once(function () { 23305 if (expectsCSS) { 23306 removeTransitionClass(el, toClass); 23307 removeTransitionClass(el, activeClass); 23308 } 23309 // @ts-expect-error 23310 if (cb.cancelled) { 23311 if (expectsCSS) { 23312 removeTransitionClass(el, startClass); 23313 } 23314 enterCancelledHook && enterCancelledHook(el); 23315 } 23316 else { 23317 afterEnterHook && afterEnterHook(el); 23318 } 23319 el._enterCb = null; 23320 })); 23321 if (!vnode.data.show) { 23322 // remove pending leave element on enter by injecting an insert hook 23323 mergeVNodeHook(vnode, 'insert', function () { 23324 var parent = el.parentNode; 23325 var pendingNode = parent && parent._pending && parent._pending[vnode.key]; 23326 if (pendingNode && 23327 pendingNode.tag === vnode.tag && 23328 pendingNode.elm._leaveCb) { 23329 pendingNode.elm._leaveCb(); 23330 } 23331 enterHook && enterHook(el, cb); 23332 }); 23333 } 23334 // start enter transition 23335 beforeEnterHook && beforeEnterHook(el); 23336 if (expectsCSS) { 23337 addTransitionClass(el, startClass); 23338 addTransitionClass(el, activeClass); 23339 nextFrame(function () { 23340 removeTransitionClass(el, startClass); 23341 // @ts-expect-error 23342 if (!cb.cancelled) { 23343 addTransitionClass(el, toClass); 23344 if (!userWantsControl) { 23345 if (isValidDuration(explicitEnterDuration)) { 23346 setTimeout(cb, explicitEnterDuration); 23347 } 23348 else { 23349 whenTransitionEnds(el, type, cb); 23350 } 23351 } 23352 } 23353 }); 23354 } 23355 if (vnode.data.show) { 23356 toggleDisplay && toggleDisplay(); 23357 enterHook && enterHook(el, cb); 23358 } 23359 if (!expectsCSS && !userWantsControl) { 23360 cb(); 23361 } 23362} 23363function leave(vnode, rm) { 23364 var el = vnode.elm; 23365 // call enter callback now 23366 if (isDef(el._enterCb)) { 23367 el._enterCb.cancelled = true; 23368 el._enterCb(); 23369 } 23370 var data = resolveTransition(vnode.data.transition); 23371 if (isUndef(data) || el.nodeType !== 1) { 23372 return rm(); 23373 } 23374 /* istanbul ignore if */ 23375 if (isDef(el._leaveCb)) { 23376 return; 23377 } 23378 var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration; 23379 var expectsCSS = css !== false && !isIE9; 23380 var userWantsControl = getHookArgumentsLength(leave); 23381 var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration); 23382 if (false) {} 23383 var cb = (el._leaveCb = once(function () { 23384 if (el.parentNode && el.parentNode._pending) { 23385 el.parentNode._pending[vnode.key] = null; 23386 } 23387 if (expectsCSS) { 23388 removeTransitionClass(el, leaveToClass); 23389 removeTransitionClass(el, leaveActiveClass); 23390 } 23391 // @ts-expect-error 23392 if (cb.cancelled) { 23393 if (expectsCSS) { 23394 removeTransitionClass(el, leaveClass); 23395 } 23396 leaveCancelled && leaveCancelled(el); 23397 } 23398 else { 23399 rm(); 23400 afterLeave && afterLeave(el); 23401 } 23402 el._leaveCb = null; 23403 })); 23404 if (delayLeave) { 23405 delayLeave(performLeave); 23406 } 23407 else { 23408 performLeave(); 23409 } 23410 function performLeave() { 23411 // the delayed leave may have already been cancelled 23412 // @ts-expect-error 23413 if (cb.cancelled) { 23414 return; 23415 } 23416 // record leaving element 23417 if (!vnode.data.show && el.parentNode) { 23418 (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = 23419 vnode; 23420 } 23421 beforeLeave && beforeLeave(el); 23422 if (expectsCSS) { 23423 addTransitionClass(el, leaveClass); 23424 addTransitionClass(el, leaveActiveClass); 23425 nextFrame(function () { 23426 removeTransitionClass(el, leaveClass); 23427 // @ts-expect-error 23428 if (!cb.cancelled) { 23429 addTransitionClass(el, leaveToClass); 23430 if (!userWantsControl) { 23431 if (isValidDuration(explicitLeaveDuration)) { 23432 setTimeout(cb, explicitLeaveDuration); 23433 } 23434 else { 23435 whenTransitionEnds(el, type, cb); 23436 } 23437 } 23438 } 23439 }); 23440 } 23441 leave && leave(el, cb); 23442 if (!expectsCSS && !userWantsControl) { 23443 cb(); 23444 } 23445 } 23446} 23447// only used in dev mode 23448function checkDuration(val, name, vnode) { 23449 if (typeof val !== 'number') { 23450 warn$2("<transition> explicit ".concat(name, " duration is not a valid number - ") + 23451 "got ".concat(JSON.stringify(val), "."), vnode.context); 23452 } 23453 else if (isNaN(val)) { 23454 warn$2("<transition>
23454 explicit ".concat(name, " duration is NaN - ") + 23455 'the duration expression might be incorrect.', vnode.context); 23456 } 23457} 23458function isValidDuration(val) { 23459 return typeof val === 'number' && !isNaN(val); 23460} 23461/** 23462 * Normalize a transition hook's argument length. The hook may be: 23463 * - a merged hook (invoker) with the original in .fns 23464 * - a wrapped component method (check ._length) 23465 * - a plain function (.length) 23466 */ 23467function getHookArgumentsLength(fn) { 23468 if (isUndef(fn)) { 23469 return false; 23470 } 23471 // @ts-expect-error 23472 var invokerFns = fn.fns; 23473 if (isDef(invokerFns)) { 23474 // invoker 23475 return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns); 23476 } 23477 else { 23478 // @ts-expect-error 23479 return (fn._length || fn.length) > 1; 23480 } 23481} 23482function _enter(_, vnode) { 23483 if (vnode.data.show !== true) { 23484 enter(vnode); 23485 } 23486} 23487var transition = inBrowser 23488 ? { 23489 create: _enter, 23490 activate: _enter, 23491 remove: function (vnode, rm) { 23492 /* istanbul ignore else */ 23493 if (vnode.data.show !== true) { 23494 // @ts-expect-error 23495 leave(vnode, rm); 23496 } 23497 else { 23498 rm(); 23499 } 23500 } 23501 } 23502 : {}; 23503 23504var platformModules = [attrs, klass$1, events, domProps, style$1, transition]; 23505 23506// the directive module should be applied last, after all 23507// built-in modules have been applied. 23508var modules$1 = platformModules.concat(baseModules); 23509var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 }); 23510 23511/** 23512 * Not type checking this file because flow doesn't like attaching 23513 * properties to Elements. 23514 */ 23515/* istanbul ignore if */ 23516if (isIE9) { 23517 // http://www.matts411.com/post/internet-explorer-9-oninput/ 23518 document.addEventListener('selectionchange', function () { 23519 var el = document.activeElement; 23520 // @ts-expect-error 23521 if (el && el.vmodel) { 23522 trigger(el, 'input'); 23523 } 23524 }); 23525} 23526var directive = { 23527 inserted: function (el, binding, vnode, oldVnode) { 23528 if (vnode.tag === 'select') { 23529 // #6903 23530 if (oldVnode.elm && !oldVnode.elm._vOptions) { 23531 mergeVNodeHook(vnode, 'postpatch', function () { 23532 directive.componentUpdated(el, binding, vnode); 23533 }); 23534 } 23535 else { 23536 setSelected(el, binding, vnode.context); 23537 } 23538 el._vOptions = [].map.call(el.options, getValue); 23539 } 23540 else if (vnode.tag === 'textarea' || isTextInputType(el.type)) { 23541 el._vModifiers = binding.modifiers; 23542 if (!binding.modifiers.lazy) { 23543 el.addEventListener('compositionstart', onCompositionStart); 23544 el.addEventListener('compositionend', onCompositionEnd); 23545 // Safari < 10.2 & UIWebView doesn't fire compositionend when 23546 // switching focus before confirming composition choice 23547 // this also fixes the issue where some browsers e.g. iOS Chrome 23548 // fires "change" instead of "input" on autocomplete. 23549 el.addEventListener('change', onCompositionEnd); 23550 /* istanbul ignore if */ 23551 if (isIE9) { 23552 el.vmodel = true; 23553 } 23554 } 23555 } 23556 }, 23557 componentUpdated: function (el, binding, vnode) { 23558 if (vnode.tag === 'select') { 23559 setSelected(el, binding, vnode.context); 23560 // in case the options rendered by v-for have changed, 23561 // it's possible that the value is out-of-sync with the rendered options. 23562 // detect such cases and filter out values that no longer has a matching 23563 // option in the DOM. 23564 var prevOptions_1 = el._vOptions; 23565 var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue)); 23566 if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) { 23567 // trigger change event if 23568 // no matching option found for at least one value 23569 var needReset = el.multiple 23570 ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); }) 23571 : binding.value !== binding.oldValue && 23572 hasNoMatchingOption(binding.value, curOptions_1); 23573 if (needReset) { 23574 trigger(el, 'change'); 23575 } 23576 } 23577 } 23578 } 23579}; 23580function setSelected(el, binding, vm) { 23581 actuallySetSelected(el, binding, vm); 23582 /* istanbul ignore if */ 23583 if (isIE || isEdge) { 23584 setTimeout(function () { 23585 actuallySetSelected(el, binding, vm); 23586 }, 0); 23587 } 23588} 23589function actuallySetSelected(el, binding, vm) { 23590 var value = binding.value; 23591 var isMultiple = el.multiple; 23592 if (isMultiple && !Array.isArray(value)) { 23593 false && 23594 0; 23595 return; 23596 } 23597 var selected, option; 23598 for (var i = 0, l = el.options.length; i < l; i++) { 23599 option = el.options[i]; 23600 if (isMultiple) { 23601 selected = looseIndexOf(value, getValue(option)) > -1; 23602 if (option.selected !== selected) { 23603 option.selected = selected; 23604 } 23605 } 23606 else { 23607 if (looseEqual(getValue(option), value)) { 23608 if (el.selectedIndex !== i) { 23609 el.selectedIndex = i; 23610 } 23611 return; 23612 } 23613 } 23614 } 23615 if (!isMultiple) { 23616 el.selectedIndex = -1; 23617 } 23618} 23619function hasNoMatchingOption(value, options) { 23620 return options.every(function (o) { return !looseEqual(o, value); }); 23621} 23622function getValue(option) { 23623 return '_value' in option ? option._value : option.value; 23624} 23625function onCompositionStart(e) { 23626 e.target.composing = true; 23627} 23628function onCompositionEnd(e) { 23629 // prevent triggering an input event for no reason 23630 if (!e.target.composing) 23631 return; 23632 e.target.composing = false;
23633 trigger(e.target, 'input'); 23634} 23635function trigger(el, type) { 23636 var e = document.createEvent('HTMLEvents'); 23637 e.initEvent(type, true, true); 23638 el.dispatchEvent(e); 23639} 23640 23641// recursively search for possible transition defined inside the component root 23642function locateNode(vnode) { 23643 // @ts-expect-error 23644 return vnode.componentInstance && (!vnode.data || !vnode.data.transition) 23645 ? locateNode(vnode.componentInstance._vnode) 23646 : vnode; 23647} 23648var show = { 23649 bind: function (el, _a, vnode) { 23650 var value = _a.value; 23651 vnode = locateNode(vnode); 23652 var transition = vnode.data && vnode.data.transition; 23653 var originalDisplay = (el.__vOriginalDisplay = 23654 el.style.display === 'none' ? '' : el.style.display); 23655 if (value && transition) { 23656 vnode.data.show = true; 23657 enter(vnode, function () { 23658 el.style.display = originalDisplay; 23659 }); 23660 } 23661 else { 23662 el.style.display = value ? originalDisplay : 'none'; 23663 } 23664 }, 23665 update: function (el, _a, vnode) { 23666 var value = _a.value, oldValue = _a.oldValue; 23667 /* istanbul ignore if */ 23668 if (!value === !oldValue) 23669 return; 23670 vnode = locateNode(vnode); 23671 var transition = vnode.data && vnode.data.transition; 23672 if (transition) { 23673 vnode.data.show = true; 23674 if (value) { 23675 enter(vnode, function () { 23676 el.style.display = el.__vOriginalDisplay; 23677 }); 23678 } 23679 else { 23680 leave(vnode, function () { 23681 el.style.display = 'none'; 23682 }); 23683 } 23684 } 23685 else { 23686 el.style.display = value ? el.__vOriginalDisplay : 'none'; 23687 } 23688 }, 23689 unbind: function (el, binding, vnode, oldVnode, isDestroy) { 23690 if (!isDestroy) { 23691 el.style.display = el.__vOriginalDisplay; 23692 } 23693 } 23694}; 23695 23696var platformDirectives = { 23697 model: directive, 23698 show: show 23699}; 23700 23701// Provides transition support for a single element/component. 23702var transitionProps = { 23703 name: String, 23704 appear: Boolean, 23705 css: Boolean, 23706 mode: String, 23707 type: String, 23708 enterClass: String, 23709 leaveClass: String, 23710 enterToClass: String, 23711 leaveToClass: String, 23712 enterActiveClass: String, 23713 leaveActiveClass: String, 23714 appearClass: String, 23715 appearActiveClass: String, 23716 appearToClass: String, 23717 duration: [Number, String, Object] 23718}; 23719// in case the child is also an abstract component, e.g. <keep-alive> 23720// we want to recursively retrieve the real component to be rendered 23721function getRealChild(vnode) { 23722 var compOptions = vnode && vnode.componentOptions; 23723 if (compOptions && compOptions.Ctor.options.abstract) { 23724 return getRealChild(getFirstComponentChild(compOptions.children)); 23725 } 23726 else { 23727 return vnode; 23728 } 23729} 23730function extractTransitionData(comp) { 23731 var data = {}; 23732 var options = comp.$options; 23733 // props 23734 for (var key in options.propsData) { 23735 data[key] = comp[key]; 23736 } 23737 // events. 23738 // extract listeners and pass them directly to the transition methods 23739 var listeners = options._parentListeners; 23740 for (var key in listeners) { 23741 data[camelize(key)] = listeners[key]; 23742 } 23743 return data; 23744} 23745function placeholder(h, rawChild) { 23746 // @ts-expect-error 23747 if (/\d-keep-alive$/.test(rawChild.tag)) { 23748 return h('keep-alive', { 23749 props: rawChild.componentOptions.propsData 23750 }); 23751 } 23752} 23753function hasParentTransition(vnode) { 23754 while ((vnode = vnode.parent)) { 23755 if (vnode.data.transition) { 23756 return true; 23757 } 23758 } 23759} 23760function isSameChild(child, oldChild) { 23761 return oldChild.key === child.key && oldChild.tag === child.tag; 23762} 23763var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); }; 23764var isVShowDirective = function (d) { return d.name === 'show'; }; 23765var Transition = { 23766 name: 'transition', 23767 props: transitionProps, 23768 abstract: true, 23769 render: function (h) { 23770 var _this = this; 23771 var children = this.$slots.default; 23772 if (!children) { 23773 return; 23774 }
23775 // filter out text nodes (possible whitespaces) 23776 children = children.filter(isNotTextNode); 23777 /* istanbul ignore if */ 23778 if (!children.length) { 23779 return; 23780 } 23781 // warn multiple elements 23782 if (false) {} 23783 var mode = this.mode; 23784 // warn invalid mode 23785 if (false) {} 23786 var rawChild = children[0]; 23787 // if this is a component root node and the component's 23788 // parent container node also has transition, skip. 23789 if (hasParentTransition(this.$vnode)) { 23790 return rawChild; 23791 } 23792 // apply transition data to child 23793 // use getRealChild() to ignore abstract components e.g. keep-alive 23794 var child = getRealChild(rawChild); 23795 /* istanbul ignore if */ 23796 if (!child) { 23797 return rawChild; 23798 } 23799 if (this._leaving) { 23800 return placeholder(h, rawChild); 23801 } 23802 // ensure a key that is unique to the vnode type and to this transition 23803 // component instance. This key will be used to remove pending leaving nodes 23804 // during entering. 23805 var id = "__transition-".concat(this._uid, "-"); 23806 child.key = 23807 child.key == null 23808 ? child.isComment 23809 ? id + 'comment' 23810 : id + child.tag 23811 : isPrimitive(child.key) 23812 ? String(child.key).indexOf(id) === 0 23813 ? child.key 23814 : id + child.key 23815 : child.key; 23816 var data = ((child.data || (child.data = {})).transition = 23817 extractTransitionData(this)); 23818 var oldRawChild = this._vnode; 23819 var oldChild = getRealChild(oldRawChild); 23820 // mark v-show 23821 // so that the transition module can hand over the control to the directive 23822 if (child.data.directives && child.data.directives.some(isVShowDirective)) { 23823 child.data.show = true; 23824 } 23825 if (oldChild && 23826 oldChild.data && 23827 !isSameChild(child, oldChild) && 23828 !isAsyncPlaceholder(oldChild) && 23829 // #6687 component root is a comment node 23830 !(oldChild.componentInstance && 23831 oldChild.componentInstance._vnode.isComment)) { 23832 // replace old child transition data with fresh one 23833 // important for dynamic transitions! 23834 var oldData = (oldChild.data.transition = extend({}, data)); 23835 // handle transition mode 23836 if (mode === 'out-in') { 23837 // return placeholder node and queue update when leave finishes 23838 this._leaving = true; 23839 mergeVNodeHook(oldData, 'afterLeave', function () { 23840 _this._leaving = false; 23841 _this.$forceUpdate(); 23842 }); 23843 return placeholder(h, rawChild); 23844 } 23845 else if (mode === 'in-out') { 23846 if (isAsyncPlaceholder(child)) { 23847 return oldRawChild; 23848 } 23849 var delayedLeave_1; 23850 var performLeave = function () { 23851 delayedLeave_1(); 23852 }; 23853 mergeVNodeHook(data, 'afterEnter', performLeave); 23854 mergeVNodeHook(data, 'enterCancelled', performLeave); 23855 mergeVNodeHook(oldData, 'delayLeave', function (leave) { 23856 delayedLeave_1 = leave; 23857 }); 23858 } 23859 } 23860 return rawChild; 23861 } 23862}; 23863 23864// Provides transition support for list items. 23865var props = extend({ 23866 tag: String, 23867 moveClass: String 23868}, transitionProps); 23869delete props.mode; 23870var TransitionGroup = { 23871 props: props, 23872 beforeMount: function () { 23873 var _this = this; 23874 var update = this._update; 23875 this._update = function (vnode, hydrating) { 23876 var restoreActiveInstance = setActiveInstance(_this); 23877 // force removing pass 23878 _this.__patch__(_this._vnode, _this.kept, false, // hydrating 23879 true // removeOnly (!important, avoids unnecessary moves) 23880 ); 23881 _this._vnode = _this.kept; 23882 restoreActiveInstance(); 23883 update.call(_this, vnode, hydrating); 23884 }; 23885 }, 23886 render: function (h) { 23887 var tag = this.tag || this.$vnode.data.tag || 'span'; 23888 var map = Object.create(null); 23889 var prevChildren = (this.prevChildren = this.children); 23890 var rawChildren = this.$slots.default || []; 23891 var children = (this.children = []); 23892 var transitionData = extractTransitionData(this); 23893 for (var i = 0; i < rawChildren.length; i++) { 23894 var c = rawChildren[i]; 23895 if (c.tag) { 23896 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { 23897 children.push(c); 23898 map[c.key] = c; 23899 (c.data || (c.data = {})).transition = transitionData; 23900 } 23901 else if (false) { var name_1, opts; } 23902 } 23903 } 23904 if (prevChildren) { 23905 var kept = []; 23906 var removed = []; 23907 for (var i = 0; i < prevChildren.length; i++) { 23908 var c = prevChildren[i]; 23909 c.data.transition = transitionData; 23910 // @ts-expect-error .getBoundingClientRect is not typed in Node 23911 c.data.pos = c.elm.getBoundingClientRect(); 23912 if (map[c.key]) { 23913 kept.push(c); 23914 } 23915 else { 23916 removed.push(c); 23917 } 23918 } 23919 this.kept = h(tag, null, kept); 23920 this.removed = removed; 23921 } 23922 return h(tag, null, children); 23923 }, 23924 updated: function () { 23925 var children = this.prevChildren; 23926 var moveClass = this.moveClass || (this.name || 'v') + '-move'; 23927 if (!children.length || !this.hasMove(children[0].elm, moveClass)) { 23928 return; 23929 } 23930 // we divide the work into three loops to avoid mixing DOM reads and writes 23931 // in each iteration - which helps prevent layout thrashing.
23932 children.forEach(callPendingCbs); 23933 children.forEach(recordPosition); 23934 children.forEach(applyTranslation); 23935 // force reflow to put everything in position 23936 // assign to this to avoid being removed in tree-shaking 23937 // $flow-disable-line 23938 this._reflow = document.body.offsetHeight; 23939 children.forEach(function (c) { 23940 if (c.data.moved) { 23941 var el_1 = c.elm; 23942 var s = el_1.style; 23943 addTransitionClass(el_1, moveClass); 23944 s.transform = s.WebkitTransform = s.transitionDuration = ''; 23945 el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) { 23946 if (e && e.target !== el_1) { 23947 return; 23948 } 23949 if (!e || /transform$/.test(e.propertyName)) { 23950 el_1.removeEventListener(transitionEndEvent, cb); 23951 el_1._moveCb = null; 23952 removeTransitionClass(el_1, moveClass); 23953 } 23954 })); 23955 } 23956 }); 23957 }, 23958 methods: { 23959 hasMove: function (el, moveClass) { 23960 /* istanbul ignore if */ 23961 if (!hasTransition) { 23962 return false; 23963 } 23964 /* istanbul ignore if */ 23965 if (this._hasMove) { 23966 return this._hasMove; 23967 } 23968 // Detect whether an element with the move class applied has 23969 // CSS transitions. Since the element may be inside an entering 23970 // transition at this very moment, we make a clone of it and remove 23971 // all other transition classes applied to ensure only the move class 23972 // is applied. 23973 var clone = el.cloneNode(); 23974 if (el._transitionClasses) { 23975 el._transitionClasses.forEach(function (cls) { 23976 removeClass(clone, cls); 23977 }); 23978 } 23979 addClass(clone, moveClass); 23980 clone.style.display = 'none'; 23981 this.$el.appendChild(clone); 23982 var info = getTransitionInfo(clone); 23983 this.$el.removeChild(clone); 23984 return (this._hasMove = info.hasTransform); 23985 } 23986 } 23987}; 23988function callPendingCbs(c) { 23989 /* istanbul ignore if */ 23990 if (c.elm._moveCb) { 23991 c.elm._moveCb(); 23992 } 23993 /* istanbul ignore if */ 23994 if (c.elm._enterCb) { 23995 c.elm._enterCb(); 23996 } 23997} 23998function recordPosition(c) { 23999 c.data.newPos = c.elm.getBoundingClientRect(); 24000} 24001function applyTranslation(c) { 24002 var oldPos = c.data.pos; 24003 var newPos = c.data.newPos; 24004 var dx = oldPos.left - newPos.left; 24005 var dy = oldPos.top - newPos.top; 24006 if (dx || dy) { 24007 c.data.moved = true; 24008 var s = c.elm.style; 24009 s.transform = s.WebkitTransform = "translate(".concat(dx, "px,").concat(dy, "px)"); 24010 s.transitionDuration = '0s'; 24011 } 24012} 24013 24014var platformComponents = { 24015 Transition: Transition, 24016 TransitionGroup: TransitionGroup 24017}; 24018 24019// install platform specific utils 24020Vue.config.mustUseProp = mustUseProp; 24021Vue.config.isReservedTag = isReservedTag; 24022Vue.config.isReservedAttr = isReservedAttr; 24023Vue.config.getTagNamespace = getTagNamespace; 24024Vue.config.isUnknownElement = isUnknownElement; 24025// install platform runtime directives & components 24026extend(Vue.options.directives, platformDirectives); 24027extend(Vue.options.components, platformComponents); 24028// install platform patch function 24029Vue.prototype.__patch__ = inBrowser ? patch : noop; 24030// public mount method 24031Vue.prototype.$mount = function (el, hydrating) { 24032 el = el && inBrowser ? query(el) : undefined; 24033 return mountComponent(this, el, hydrating); 24034}; 24035// devtools global hook 24036/* istanbul ignore next */ 24037if (inBrowser) { 24038 setTimeout(function () { 24039 if (config.devtools) { 24040 if (devtools) { 24041 devtools.emit('init', Vue); 24042 } 24043 else if (false) {} 24044 } 24045 if (false) {} 24046 }, 0); 24047} 24048 24049var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g; 24050var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; 24051var buildRegex = cached(function (delimiters) { 24052 var open = delimiters[0].replace(regexEscapeRE, '\\$&'); 24053 var close = delimiters[1].replace(regexEscapeRE, '\\$&'); 24054 return new RegExp(open + '((?:.|\\n)+?)' + close, 'g'); 24055}); 24056function parseText(text, delimiters) { 24057 //@ts-expect-error 24058 var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; 24059 if (!tagRE.test(text)) { 24060 return; 24061 } 24062 var tokens = []; 24063 var rawTokens = []; 24064 var lastIndex = (tagRE.lastIndex = 0); 24065 var match, index, tokenValue; 24066 while ((match = tagRE.exec(text))) { 24067 index = match.index; 24068 // push text token 24069 if (index > lastIndex) { 24070 rawTokens.push((tokenValue = text.slice(lastIndex, index))); 24071 tokens.push(JSON.stringify(tokenValue)); 24072 } 24073 // tag token 24074 var exp = parseFilters(match[1].trim()); 24075 tokens.push("_s(".concat(exp, ")")); 24076 rawTokens.push({ '@binding': exp }); 24077 lastIndex = index + match[0].length; 24078 } 24079 if (lastIndex < text.length) { 24080 rawTokens.push((tokenValue = text.slice(lastIndex))); 24081 tokens.push(JSON.stringify(tokenValue)); 24082 } 24083 return { 24084 expression: tokens.join('+'), 24085 tokens: rawTokens 24086 }; 24087} 24088 24089function transformNode$1(el, options) { 24090 var warn = options.warn || baseWarn; 24091 var staticClass = getAndRemoveAttr(el, 'class'); 24092 if (false) { var res; } 24093 if (staticClass) { 24094 el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim()); 24095 } 24096 var classBinding = getBindingAttr(el, 'class', false /* getStatic */); 24097 if (classBinding) { 24098 el.classBinding = classBinding; 24099 } 24100} 24101function genData$2(el) { 24102 var data = ''; 24103 if (el.staticClass) { 24104 data += "staticClass:".concat(el.staticClass, ","); 24105 } 24106 if (el.classBinding) { 24107 data += "class:".concat(el.classBinding, ","); 24108 } 24109 return data; 24110} 24111var klass = { 24112 staticKeys: ['staticClass'], 24113 transformNode: transformNode$1, 24114 genData: genData$2 24115}; 24116 24117function transformNode(el, options) { 24118 var warn = options.warn || baseWarn; 24119 var staticStyle = getAndRemoveAttr(el, 'style'); 24120 if (staticStyle) { 24121 /* istanbul ignore if */ 24122 if (false) { var res; } 24123 el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); 24124 } 24125 var styleBinding = getBindingAttr(el, 'style', false /* getStatic */); 24126 if (styleBinding) { 24127 el.styleBinding = styleBinding; 24128 } 24129} 24130function genData$1(el) { 24131 var data = ''; 24132 if (el.staticStyle) { 24133 data += "staticStyle:".concat(el.staticStyle, ","); 24134 } 24135 if (el.styleBinding) { 24136 data += "style:(".concat(el.styleBinding, "),"); 24137 } 24138 return data; 24139} 24140var style = { 24141 staticKeys: ['staticStyle'], 24142 transformNode: transformNode, 24143 genData: genData$1 24144}; 24145 24146var decoder; 24147var he = { 24148 decode: function (html) { 24149 decoder = decoder || document.createElement('div'); 24150 decoder.innerHTML = html; 24151 return decoder.textContent; 24152 } 24153}; 24154 24155var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 24156 'link,meta,param,source,track,wbr'); 24157// Elements that you can, intentionally, leave open 24158// (and which close themselves)
24159var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'); 24160// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 24161// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content 24162var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 24163 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 24164 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 24165 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 24166 'title,tr,track'); 24167 24168/** 24169 * Not type-checking this file because it's mostly vendor code. 24170 */ 24171// Regular Expressions for parsing tags and attributes 24172var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 24173var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 24174var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z".concat(unicodeRegExp.source, "]*"); 24175var qnameCapture = "((?:".concat(ncname, "\\:)?").concat(ncname, ")"); 24176var startTagOpen = new RegExp("^<".concat(qnameCapture)); 24177var startTagClose = /^\s*(\/?)>/; 24178var endTag = new RegExp("^<\\/".concat(qnameCapture, "[^>]*>")); 24179var doctype = /^<!DOCTYPE [^>]+>/i; 24180// #7298: escape - to avoid being passed as HTML comment when inlined in page 24181var comment = /^<!\--/; 24182var conditionalComment = /^<!\[/; 24183// Special Elements (can contain anything) 24184var isPlainTextElement = makeMap('script,style,textarea', true); 24185var reCache = {}; 24186var decodingMap = { 24187 '<': '<', 24188 '>': '>', 24189 '"': '"', 24190 '&': '&', 24191 ' ': '\n', 24192 '	': '\t', 24193 ''': "'" 24194}; 24195var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g; 24196var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g; 24197// #5992 24198var isIgnoreNewlineTag = makeMap('pre,textarea', true); 24199var shouldIgnoreFirstNewline = function (tag, html) { 24200 return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; 24201}; 24202function decodeAttr(value, shouldDecodeNewlines) { 24203 var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; 24204 return value.replace(re, function (match) { return decodingMap[match]; }); 24205} 24206function parseHTML(html, options) { 24207 var stack = []; 24208 var expectHTML = options.expectHTML; 24209 var isUnaryTag = options.isUnaryTag || no; 24210 var canBeLeftOpenTag = options.canBeLeftOpenTag || no; 24211 var index = 0; 24212 var last, lastTag; 24213 var _loop_1 = function () { 24214 last = html; 24215 // Make sure we're not in a plaintext content element like script/style 24216 if (!lastTag || !isPlainTextElement(lastTag)) { 24217 var textEnd = html.indexOf('<'); 24218 if (textEnd === 0) { 24219 // Comment: 24220 if (comment.test(html)) { 24221 var commentEnd = html.indexOf('-->'); 24222 if (commentEnd >= 0) { 24223 if (options.shouldKeepComment && options.comment) { 24224 options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3); 24225 } 24226 advance(commentEnd + 3); 24227 return "continue"; 24228 } 24229 } 24230 // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment 24231 if (conditionalComment.test(html)) { 24232 var conditionalEnd = html.indexOf(']>'); 24233 if (conditionalEnd >= 0) { 24234 advance(conditionalEnd + 2); 24235 return "continue"; 24236 } 24237 } 24238 // Doctype: 24239 var doctypeMatch = html.match(doctype); 24240 if (doctypeMatch) { 24241 advance(doctypeMatch[0].length); 24242 return "continue"; 24243 } 24244 // End tag: 24245 var endTagMatch = html.match(endTag); 24246 if (endTagMatch) { 24247 var curIndex = index; 24248 advance(endTagMatch[0].length); 24249 parseEndTag(endTagMatch[1], curIndex, index); 24250 return "continue";
24251 } 24252 // Start tag: 24253 var startTagMatch = parseStartTag(); 24254 if (startTagMatch) { 24255 handleStartTag(startTagMatch); 24256 if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) { 24257 advance(1); 24258 } 24259 return "continue"; 24260 } 24261 } 24262 var text = void 0, rest = void 0, next = void 0; 24263 if (textEnd >= 0) { 24264 rest = html.slice(textEnd); 24265 while (!endTag.test(rest) && 24266 !startTagOpen.test(rest) && 24267 !comment.test(rest) && 24268 !conditionalComment.test(rest)) { 24269 // < in plain text, be forgiving and treat it as text 24270 next = rest.indexOf('<', 1); 24271 if (next < 0) 24272 break; 24273 textEnd += next; 24274 rest = html.slice(textEnd); 24275 } 24276 text = html.substring(0, textEnd); 24277 } 24278 if (textEnd < 0) { 24279 text = html; 24280 } 24281 if (text) { 24282 advance(text.length); 24283 } 24284 if (options.chars && text) { 24285 options.chars(text, index - text.length, index); 24286 } 24287 } 24288 else { 24289 var endTagLength_1 = 0; 24290 var stackedTag_1 = lastTag.toLowerCase(); 24291 var reStackedTag = reCache[stackedTag_1] || 24292 (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i')); 24293 var rest = html.replace(reStackedTag, function (all, text, endTag) { 24294 endTagLength_1 = endTag.length; 24295 if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') { 24296 text = text 24297 .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298 24298 .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1'); 24299 } 24300 if (shouldIgnoreFirstNewline(stackedTag_1, text)) { 24301 text = text.slice(1); 24302 } 24303 if (options.chars) { 24304 options.chars(text); 24305 } 24306 return ''; 24307 }); 24308 index += html.length - rest.length; 24309 html = rest; 24310 parseEndTag(stackedTag_1, index - endTagLength_1, index); 24311 } 24312 if (html === last) { 24313 options.chars && options.chars(html); 24314 if (false) {} 24315 return "break"; 24316 } 24317 }; 24318 while (html) { 24319 var state_1 = _loop_1(); 24320 if (state_1 === "break") 24321 break; 24322 } 24323 // Clean up any remaining tags 24324 parseEndTag(); 24325 function advance(n) { 24326 index += n; 24327 html = html.substring(n); 24328 } 24329 function parseStartTag() { 24330 var start = html.match(startTagOpen); 24331 if (start) { 24332 var match = { 24333 tagName: start[1], 24334 attrs: [], 24335 start: index 24336 }; 24337 advance(start[0].length); 24338 var end = void 0, attr = void 0; 24339 while (!(end = html.match(startTagClose)) && 24340 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) { 24341 attr.start = index; 24342 advance(attr[0].length); 24343 attr.end = index; 24344 match.attrs.push(attr); 24345 } 24346 if (end) { 24347 match.unarySlash = end[1]; 24348 advance(end[0].length); 24349 match.end = index; 24350 return match; 24351 } 24352 } 24353 } 24354 function handleStartTag(match) { 24355 var tagName = match.tagName; 24356 var unarySlash = match.unarySlash; 24357 if (expectHTML) { 24358 if (lastTag === 'p' && isNonPhrasingTag(tagName)) { 24359 parseEndTag(lastTag); 24360 } 24361 if (canBeLeftOpenTag(tagName) && lastTag === tagName) { 24362 parseEndTag(tagName); 24363 } 24364 } 24365 var unary = isUnaryTag(tagName) || !!unarySlash; 24366 var l = match.attrs.length; 24367 var attrs = new Array(l); 24368 for (var i = 0; i < l; i++) { 24369 var args = match.attrs[i]; 24370 var value = args[3] || args[4] || args[5] || ''; 24371 var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' 24372 ? options.shouldDecodeNewlinesForHref 24373 : options.shouldDecodeNewlines; 24374 attrs[i] = { 24375 name: args[1], 24376 value: decodeAttr(value, shouldDecodeNewlines) 24377 }; 24378 if (false) {} 24379 } 24380 if (!unary) { 24381 stack.push({ 24382 tag: tagName, 24383 lowerCasedTag: tagName.toLowerCase(), 24384 attrs: attrs, 24385 start: match.start, 24386 end: match.end 24387 }); 24388 lastTag = tagName; 24389 } 24390 if (options.start) { 24391 options.start(tagName, attrs, unary, match.start, match.end); 24392 } 24393 } 24394 function parseEndTag(tagName, start, end) { 24395 var pos, lowerCasedTagName; 24396 if (start == null) 24397 start = index; 24398 if (end == null) 24399 end = index; 24400 // Find the closest opened tag of the same type 24401 if (tagName) { 24402 lowerCasedTagName = tagName.toLowerCase(); 24403 for (pos = stack.length - 1; pos >= 0; pos--) { 24404 if (stack[pos].lowerCasedTag === lowerCasedTagName) { 24405 break; 24406 } 24407 } 24408 } 24409 else { 24410 // If no tag name is provided, clean shop 24411 pos = 0; 24412 } 24413 if (pos >= 0) { 24414 // Close all the open elements, up the stack 24415 for (var i = stack.length - 1; i >= pos; i--) { 24416 if (false) {} 24417 if (options.end) { 24418 options.end(stack[i].tag, start, end); 24419 } 24420 } 24421 // Remove the open elements from the stack 24422 stack.length = pos; 24423 lastTag = pos && stack[pos - 1].tag; 24424 } 24425 else if (lowerCasedTagName === 'br') { 24426 if (options.start) { 24427 options.start(tagName, [], true, start, end); 24428 } 24429 } 24430 else if (lowerCasedTagName === 'p') { 24431 if (options.start) { 24432 options.start(tagName, [], false, start, end); 24433 } 24434 if (options.end) { 24435 options.end(tagName, start, end); 24436 } 24437 } 24438 } 24439} 24440 24441var onRE = /^@|^v-on:/; 24442var dirRE = /^v-|^@|^:|^#/; 24443var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/; 24444var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; 24445var stripParensRE = /^\(|\)$/g; 24446var dynamicArgRE = /^\[.*\]$/; 24447var argRE = /:(.*)$/; 24448var bindRE = /^:|^\.|^v-bind:/; 24449var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g; 24450var slotRE = /^v-slot(:|$)|^#/; 24451var lineBreakRE = /[\r\n]/; 24452var whitespaceRE = /[ \f\t\r\n]+/g; 24453var invalidAttributeRE = /[\s"'<>\/=]/;
24454var decodeHTMLCached = cached(he.decode); 24455var emptySlotScopeToken = "_empty_"; 24456// configurable state 24457var warn; 24458var delimiters; 24459var transforms; 24460var preTransforms; 24461var postTransforms; 24462var platformIsPreTag; 24463var platformMustUseProp; 24464var platformGetTagNamespace; 24465var maybeComponent; 24466function createASTElement(tag, attrs, parent) { 24467 return { 24468 type: 1, 24469 tag: tag, 24470 attrsList: attrs, 24471 attrsMap: makeAttrsMap(attrs), 24472 rawAttrsMap: {}, 24473 parent: parent, 24474 children: [] 24475 }; 24476} 24477/** 24478 * Convert HTML string to AST. 24479 */ 24480function parse(template, options) { 24481 warn = options.warn || baseWarn; 24482 platformIsPreTag = options.isPreTag || no; 24483 platformMustUseProp = options.mustUseProp || no; 24484 platformGetTagNamespace = options.getTagNamespace || no; 24485 var isReservedTag = options.isReservedTag || no; 24486 maybeComponent = function (el) { 24487 return !!(el.component || 24488 el.attrsMap[':is'] || 24489 el.attrsMap['v-bind:is'] || 24490 !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); 24491 }; 24492 transforms = pluckModuleFunction(options.modules, 'transformNode'); 24493 preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); 24494 postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); 24495 delimiters = options.delimiters; 24496 var stack = []; 24497 var preserveWhitespace = options.preserveWhitespace !== false; 24498 var whitespaceOption = options.whitespace; 24499 var root; 24500 var currentParent; 24501 var inVPre = false; 24502 var inPre = false; 24503 var warned = false; 24504 function warnOnce(msg, range) { 24505 if (!warned) { 24506 warned = true; 24507 warn(msg, range); 24508 } 24509 } 24510 function closeElement(element) { 24511 trimEndingWhitespace(element); 24512 if (!inVPre && !element.processed) { 24513 element = processElement(element, options); 24514 } 24515 // tree management 24516 if (!stack.length && element !== root) { 24517 // allow root elements with v-if, v-else-if and v-else 24518 if (root.if && (element.elseif || element.else)) { 24519 if (false) {} 24520 addIfCondition(root, { 24521 exp: element.elseif, 24522 block: element 24523 }); 24524 } 24525 else if (false) {} 24526 } 24527 if (currentParent && !element.forbidden) { 24528 if (element.elseif || element.else) { 24529 processIfConditions(element, currentParent); 24530 } 24531 else { 24532 if (element.slotScope) { 24533 // scoped slot 24534 // keep it in the children list so that v-else(-if) conditions can 24535 // find it as the prev node. 24536 var name_1 = element.slotTarget || '"default"'; 24537 (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element; 24538 } 24539 currentParent.children.push(element); 24540 element.parent = currentParent; 24541 } 24542 } 24543 // final children cleanup 24544 // filter out scoped slots 24545 element.children = element.children.filter(function (c) { return !c.slotScope; }); 24546 // remove trailing whitespace node again 24547 trimEndingWhitespace(element); 24548 // check pre state 24549 if (element.pre) { 24550 inVPre = false; 24551 } 24552 if (platformIsPreTag(element.tag)) { 24553 inPre = false; 24554 } 24555 // apply post-transforms 24556 for (var i = 0; i < postTransforms.length; i++) { 24557 postTransforms[i](element, options); 24558 } 24559 } 24560 function trimEndingWhitespace(el) { 24561 // remove trailing whitespace node 24562 if (!inPre) { 24563 var lastNode = void 0; 24564 while ((lastNode = el.children[el.children.length - 1]) && 24565 lastNode.type === 3 && 24566 lastNode.text === ' ') { 24567 el.children.pop(); 24568 } 24569 } 24570 } 24571 function checkRootConstraints(el) { 24572 if (el.tag === 'slot' || el.tag === 'template') { 24573 warnOnce("Cannot use <".concat(el.tag, "> as component root element because it may ") + 24574 'contain multiple nodes.', { start: el.start }); 24575 } 24576 if (el.attrsMap.hasOwnProperty('v-for')) { 24577 warnOnce('Cannot use v-for on stateful component root element because ' + 24578 'it renders multiple elements.', el.rawAttrsMap['v-for']); 24579 } 24580 } 24581 parseHTML(template, { 24582 warn: warn, 24583 expectHTML: options.expectHTML, 24584 isUnaryTag: options.isUnaryTag, 24585 canBeLeftOpenTag: options.canBeLeftOpenTag, 24586 shouldDecodeNewlines: options.shouldDecodeNewlines, 24587 shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, 24588 shouldKeepComment: options.comments, 24589 outputSourceRange: options.outputSourceRange, 24590 start: function (tag, attrs, unary, start, end) { 24591 // check namespace. 24592 // inherit parent ns if there is one 24593 var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); 24594 // handle IE svg bug 24595 /* istanbul ignore if */ 24596 if (isIE && ns === 'svg') { 24597 attrs = guardIESVGBug(attrs); 24598 } 24599 var element = createASTElement(tag, attrs, currentParent); 24600 if (ns) { 24601 element.ns = ns; 24602 } 24603 if (false) {} 24604 if (isForbiddenTag(element) && !isServerRendering()) { 24605 element.forbidden = true; 24606 false && 24607 0; 24608 } 24609 // apply pre-transforms 24610 for (var i = 0; i < preTransforms.length; i++) { 24611 element = preTransforms[i](element, options) || element; 24612 } 24613 if (!inVPre) { 24614 processPre(element); 24615 if (element.pre) { 24616 inVPre = true; 24617 } 24618 } 24619 if (platformIsPreTag(element.tag)) { 24620 inPre = true; 24621 } 24622 if (inVPre) { 24623 processRawAttrs(element); 24624 } 24625 else if (!element.processed) { 24626 // structural directives 24627 processFor(element); 24628 processIf(element); 24629 processOnce(element); 24630 } 24631 if (!root) { 24632 root = element; 24633 if (false) {} 24634 } 24635 if (!unary) { 24636 currentParent = element; 24637 stack.push(element); 24638 } 24639 else { 24640 closeElement(element); 24641 } 24642 }, 24643 end: function (tag, start, end) { 24644 var element = stack[stack.length - 1]; 24645 // pop stack 24646 stack.length -= 1; 24647 currentParent = stack[stack.length - 1]; 24648 if (false) {} 24649 closeElement(element); 24650 }, 24651 chars: function (text, start, end) { 24652 if (!currentParent) { 24653 if (false) {} 24654 return; 24655 } 24656 // IE textarea placeholder bug 24657 /* istanbul ignore if */ 24658 if (isIE && 24659 currentParent.tag === 'textarea' && 24660 currentParent.attrsMap.placeholder === text) { 24661 return; 24662 } 24663 var children = currentParent.children; 24664 if (inPre || text.trim()) { 24665 text = isTextTag(currentParent) 24666 ? text 24667 : decodeHTMLCached(text); 24668 } 24669 else if (!children.length) { 24670 // remove the whitespace-only node right after an opening tag 24671 text = ''; 24672 } 24673 else if (whitespaceOption) { 24674 if (whitespaceOption === 'condense') { 24675 // in condense mode, remove the whitespace node if it contains 24676 // line break, otherwise condense to a single space 24677 text = lineBreakRE.test(text) ? '' : ' '; 24678 } 24679 else { 24680 text = ' '; 24681 } 24682 } 24683 else { 24684 text = preserveWhitespace ? ' ' : ''; 24685 } 24686 if (text) { 24687 if (!inPre && whitespaceOption === 'condense') {
24688 // condense consecutive whitespaces into single space 24689 text = text.replace(whitespaceRE, ' '); 24690 } 24691 var res = void 0; 24692 var child = void 0; 24693 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) { 24694 child = { 24695 type: 2, 24696 expression: res.expression, 24697 tokens: res.tokens, 24698 text: text 24699 }; 24700 } 24701 else if (text !== ' ' || 24702 !children.length || 24703 children[children.length - 1].text !== ' ') { 24704 child = { 24705 type: 3, 24706 text: text 24707 }; 24708 } 24709 if (child) { 24710 if (false) {} 24711 children.push(child); 24712 } 24713 } 24714 }, 24715 comment: function (text, start, end) { 24716 // adding anything as a sibling to the root node is forbidden 24717 // comments should still be allowed, but ignored 24718 if (currentParent) { 24719 var child = { 24720 type: 3, 24721 text: text, 24722 isComment: true 24723 }; 24724 if (false) {} 24725 currentParent.children.push(child); 24726 } 24727 } 24728 }); 24729 return root; 24730} 24731function processPre(el) { 24732 if (getAndRemoveAttr(el, 'v-pre') != null) { 24733 el.pre = true; 24734 } 24735} 24736function processRawAttrs(el) { 24737 var list = el.attrsList; 24738 var len = list.length; 24739 if (len) { 24740 var attrs = (el.attrs = new Array(len)); 24741 for (var i = 0; i < len; i++) { 24742 attrs[i] = { 24743 name: list[i].name, 24744 value: JSON.stringify(list[i].value) 24745 }; 24746 if (list[i].start != null) { 24747 attrs[i].start = list[i].start; 24748 attrs[i].end = list[i].end; 24749 } 24750 } 24751 } 24752 else if (!el.pre) { 24753 // non root node in pre blocks with no attributes 24754 el.plain = true; 24755 } 24756} 24757function processElement(element, options) { 24758 processKey(element); 24759 // determine whether this is a plain element after 24760 // removing structural attributes 24761 element.plain = 24762 !element.key && !element.scopedSlots && !element.attrsList.length; 24763 processRef(element); 24764 processSlotContent(element); 24765 processSlotOutlet(element); 24766 processComponent(element); 24767 for (var i = 0; i < transforms.length; i++) { 24768 element = transforms[i](element, options) || element; 24769 } 24770 processAttrs(element); 24771 return element; 24772} 24773function processKey(el) { 24774 var exp = getBindingAttr(el, 'key'); 24775 if (exp) { 24776 if (false) { var parent_1, iterator; } 24777 el.key = exp; 24778 } 24779} 24780function processRef(el) { 24781 var ref = getBindingAttr(el, 'ref'); 24782 if (ref) { 24783 el.ref = ref; 24784 el.refInFor = checkInFor(el); 24785 } 24786} 24787function processFor(el) { 24788 var exp; 24789 if ((exp = getAndRemoveAttr(el, 'v-for'))) { 24790 var res = parseFor(exp); 24791 if (res) { 24792 extend(el, res); 24793 } 24794 else if (false) {} 24795 } 24796} 24797function parseFor(exp) { 24798 var inMatch = exp.match(forAliasRE); 24799 if (!inMatch) 24800 return; 24801 var res = {}; 24802 res.for = inMatch[2].trim(); 24803 var alias = inMatch[1].trim().replace(stripParensRE, ''); 24804 var iteratorMatch = alias.match(forIteratorRE); 24805 if (iteratorMatch) { 24806 res.alias = alias.replace(forIteratorRE, '').trim(); 24807 res.iterator1 = iteratorMatch[1].trim(); 24808 if (iteratorMatch[2]) { 24809 res.iterator2 = iteratorMatch[2].trim(); 24810 } 24811 } 24812 else { 24813 res.alias = alias; 24814 } 24815 return res; 24816} 24817function processIf(el) { 24818 var exp = getAndRemoveAttr(el, 'v-if'); 24819 if (exp) { 24820 el.if = exp; 24821 addIfCondition(el, { 24822 exp: exp, 24823 block: el 24824 }); 24825 } 24826 else { 24827 if (getAndRemoveAttr(el, 'v-else') != null) { 24828 el.else = true; 24829 } 24830 var elseif = getAndRemoveAttr(el, 'v-else-if'); 24831 if (elseif) { 24832 el.elseif = elseif; 24833 } 24834 } 24835} 24836function processIfConditions(el, parent) { 24837 var prev = findPrevElement(parent.children); 24838 if (prev && prev.if) { 24839 addIfCondition(prev, { 24840 exp: el.elseif, 24841 block: el 24842 }); 24843 } 24844 else if (false) {} 24845} 24846function findPrevElement(children) { 24847 var i = children.length; 24848 while (i--) { 24849 if (children[i].type === 1) { 24850 return children[i]; 24851 } 24852 else { 24853 if (false) {} 24854 children.pop(); 24855 } 24856 } 24857} 24858function addIfCondition(el, condition) { 24859 if (!el.ifConditions) { 24860 el.ifConditions = []; 24861 } 24862 el.ifConditions.push(condition); 24863} 24864function processOnce(el) { 24865 var once = getAndRemoveAttr(el, 'v-once'); 24866 if (once != null) { 24867 el.once = true; 24868 } 24869} 24870// handle content being passed to a component as slot,
24871// e.g. <template slot="xxx">, <div slot-scope="xxx"> 24872function processSlotContent(el) { 24873 var slotScope; 24874 if (el.tag === 'template') { 24875 slotScope = getAndRemoveAttr(el, 'scope'); 24876 /* istanbul ignore if */ 24877 if (false) {} 24878 el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope'); 24879 } 24880 else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { 24881 /* istanbul ignore if */ 24882 if (false) {} 24883 el.slotScope = slotScope; 24884 } 24885 // slot="xxx" 24886 var slotTarget = getBindingAttr(el, 'slot'); 24887 if (slotTarget) { 24888 el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; 24889 el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']); 24890 // preserve slot as an attribute for native shadow DOM compat 24891 // only for non-scoped slots. 24892 if (el.tag !== 'template' && !el.slotScope) { 24893 addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot')); 24894 } 24895 } 24896 // 2.6 v-slot syntax 24897 { 24898 if (el.tag === 'template') { 24899 // v-slot on <template> 24900 var slotBinding = getAndRemoveAttrByRegex(el, slotRE); 24901 if (slotBinding) { 24902 if (false) {} 24903 var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic; 24904 el.slotTarget = name_2; 24905 el.slotTargetDynamic = dynamic; 24906 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf 24907 } 24908 } 24909 else { 24910 // v-slot on component, denotes default slot 24911 var slotBinding = getAndRemoveAttrByRegex(el, slotRE); 24912 if (slotBinding) { 24913 if (false) {} 24914 // add the component's children to its default slot 24915 var slots = el.scopedSlots || (el.scopedSlots = {}); 24916 var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic; 24917 var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el)); 24918 slotContainer_1.slotTarget = name_3; 24919 slotContainer_1.slotTargetDynamic = dynamic; 24920 slotContainer_1.children = el.children.filter(function (c) { 24921 if (!c.slotScope) { 24922 c.parent = slotContainer_1; 24923 return true; 24924 } 24925 }); 24926 slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken; 24927 // remove children as they are returned from scopedSlots now 24928 el.children = []; 24929 // mark el non-plain so data gets generated 24930 el.plain = false; 24931 } 24932 } 24933 } 24934} 24935function getSlotName(binding) { 24936 var name = binding.name.replace(slotRE, ''); 24937 if (!name) { 24938 if (binding.name[0] !== '#') { 24939 name = 'default'; 24940 } 24941 else if (false) {} 24942 } 24943 return dynamicArgRE.test(name) 24944 ? // dynamic [name] 24945 { name: name.slice(1, -1), dynamic: true } 24946 : // static name 24947 { name: "\"".concat(name, "\""), dynamic: false }; 24948} 24949// handle <slot/> outlets 24950function processSlotOutlet(el) { 24951 if (el.tag === 'slot') { 24952 el.slotName = getBindingAttr(el, 'name'); 24953 if (false) {} 24954 } 24955} 24956function processComponent(el) { 24957 var binding; 24958 if ((binding = getBindingAttr(el, 'is'))) { 24959 el.component = binding; 24960 } 24961 if (getAndRemoveAttr(el, 'inline-template') != null) { 24962 el.inlineTemplate = true; 24963 } 24964} 24965function processAttrs(el) { 24966 var list = el.attrsList; 24967 var i, l, name, rawName, value, modifiers, syncGen, isDynamic; 24968 for (i = 0, l = list.length; i < l; i++) { 24969 name = rawName = list[i].name; 24970 value = list[i].value; 24971 if (dirRE.test(name)) { 24972 // mark element as dynamic 24973 el.hasBindings = true; 24974 // modifiers 24975 modifiers = parseModifiers(name.replace(dirRE, '')); 24976 // support .foo shorthand syntax for the .prop modifier 24977 if (modifiers) { 24978 name = name.replace(modifierRE, ''); 24979 } 24980 if (bindRE.test(name)) { 24981 // v-bind 24982 name = name.replace(bindRE, ''); 24983 value = parseFilters(value); 24984 isDynamic = dynamicArgRE.test(name); 24985 if (isDynamic) { 24986 name = name.slice(1, -1); 24987 } 24988 if (false) {} 24989 if (modifiers) { 24990 if (modifiers.prop && !isDynamic) { 24991 name = camelize(name); 24992 if (name === 'innerHtml') 24993 name = 'innerHTML'; 24994 } 24995 if (modifiers.camel && !isDynamic) { 24996 name = camelize(name); 24997 } 24998 if (modifiers.sync) {
24999 syncGen = genAssignmentCode(value, "$event"); 25000 if (!isDynamic) { 25001 addHandler(el, "update:".concat(camelize(name)), syncGen, null, false, warn, list[i]); 25002 if (hyphenate(name) !== camelize(name)) { 25003 addHandler(el, "update:".concat(hyphenate(name)), syncGen, null, false, warn, list[i]); 25004 } 25005 } 25006 else { 25007 // handler w/ dynamic event name 25008 addHandler(el, "\"update:\"+(".concat(name, ")"), syncGen, null, false, warn, list[i], true // dynamic 25009 ); 25010 } 25011 } 25012 } 25013 if ((modifiers && modifiers.prop) || 25014 (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) { 25015 addProp(el, name, value, list[i], isDynamic); 25016 } 25017 else { 25018 addAttr(el, name, value, list[i], isDynamic); 25019 } 25020 } 25021 else if (onRE.test(name)) { 25022 // v-on 25023 name = name.replace(onRE, ''); 25024 isDynamic = dynamicArgRE.test(name); 25025 if (isDynamic) { 25026 name = name.slice(1, -1); 25027 } 25028 addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic); 25029 } 25030 else { 25031 // normal directives 25032 name = name.replace(dirRE, ''); 25033 // parse arg 25034 var argMatch = name.match(argRE); 25035 var arg = argMatch && argMatch[1]; 25036 isDynamic = false; 25037 if (arg) { 25038 name = name.slice(0, -(arg.length + 1)); 25039 if (dynamicArgRE.test(arg)) { 25040 arg = arg.slice(1, -1); 25041 isDynamic = true; 25042 } 25043 } 25044 addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]); 25045 if (false) {} 25046 } 25047 } 25048 else { 25049 // literal attribute 25050 if (false) { var res; } 25051 addAttr(el, name, JSON.stringify(value), list[i]); 25052 // #6887 firefox doesn't update muted state if set via attribute 25053 // even immediately after element creation 25054 if (!el.component && 25055 name === 'muted' && 25056 platformMustUseProp(el.tag, el.attrsMap.type, name)) { 25057 addProp(el, name, 'true', list[i]); 25058 } 25059 } 25060 } 25061} 25062function checkInFor(el) { 25063 var parent = el; 25064 while (parent) { 25065 if (parent.for !== undefined) { 25066 return true; 25067 } 25068 parent = parent.parent; 25069 } 25070 return false; 25071} 25072function parseModifiers(name) { 25073 var match = name.match(modifierRE); 25074 if (match) { 25075 var ret_1 = {}; 25076 match.forEach(function (m) { 25077 ret_1[m.slice(1)] = true; 25078 }); 25079 return ret_1; 25080 } 25081} 25082function makeAttrsMap(attrs) { 25083 var map = {}; 25084 for (var i = 0, l = attrs.length; i < l; i++) { 25085 if (false) {} 25086 map[attrs[i].name] = attrs[i].value; 25087 } 25088 return map; 25089} 25090// for script (e.g. type="x/template") or style, do not decode content 25091function isTextTag(el) { 25092 return el.tag === 'script' || el.tag === 'style'; 25093} 25094function isForbiddenTag(el) { 25095 return (el.tag === 'style' || 25096 (el.tag === 'script' && 25097 (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))); 25098} 25099var ieNSBug = /^xmlns:NS\d+/; 25100var ieNSPrefix = /^NS\d+:/; 25101/* istanbul ignore next */ 25102function guardIESVGBug(attrs) { 25103 var res = []; 25104 for (var i = 0; i < attrs.length; i++) { 25105 var attr = attrs[i]; 25106 if (!ieNSBug.test(attr.name)) { 25107 attr.name = attr.name.replace(ieNSPrefix, ''); 25108 res.push(attr); 25109 } 25110 } 25111 return res; 25112} 25113function checkForAliasModel(el, value) { 25114 var _el = el; 25115 while (_el) { 25116 if (_el.for && _el.alias === value) { 25117 warn("<".concat(el.tag, " v-model=\"").concat(value, "\">: ") + 25118 "You are binding v-model directly to a v-for iteration alias. " + 25119 "This will not be able to modify the v-for source array because " + 25120 "writing to the alias is like modifying a function local variable. " + 25121 "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']); 25122 } 25123 _el = _el.parent; 25124 } 25125} 25126 25127/** 25128 * Expand input[v-model] with dynamic type bindings into v-if-else chains 25129 * Turn this: 25130 * <input v-model="data[type]" :type="type"> 25131 * into this: 25132 * <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]"> 25133 * <input v-else-if="type === 'radio'" type="radio" v-model="data[type]"> 25134 * <input v-else :type="type" v-model="data[type]"> 25135 */ 25136function preTransformNode(el, options) { 25137 if (el.tag === 'input') { 25138 var map = el.attrsMap; 25139 if (!map['v-model']) { 25140 return; 25141 } 25142 var typeBinding = void 0; 25143 if (map[':type'] || map['v-bind:type']) { 25144 typeBinding = getBindingAttr(el, 'type'); 25145 } 25146 if (!map.type && !typeBinding && map['v-bind']) { 25147 typeBinding = "(".concat(map['v-bind'], ").type"); 25148 } 25149 if (typeBinding) { 25150 var ifCondition = getAndRemoveAttr(el, 'v-if', true); 25151 var ifConditionExtra = ifCondition ? "&&(".concat(ifCondition, ")") : ""; 25152 var hasElse = getAndRemoveAttr(el, 'v-else', true) != null; 25153 var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); 25154 // 1. checkbox 25155 var branch0 = cloneASTElement(el); 25156 // process for on the main node 25157 processFor(branch0); 25158 addRawAttr(branch0, 'type', 'checkbox'); 25159 processElement(branch0, options); 25160 branch0.processed = true; // prevent it from double-processed 25161 branch0.if = "(".concat(typeBinding, ")==='checkbox'") + ifConditionExtra; 25162 addIfCondition(branch0, { 25163 exp: branch0.if, 25164 block: branch0 25165 }); 25166 // 2. add radio else-if condition 25167 var branch1 = cloneASTElement(el); 25168 getAndRemoveAttr(branch1, 'v-for', true); 25169 addRawAttr(branch1, 'type', 'radio'); 25170 processElement(branch1, options); 25171 addIfCondition(branch0, { 25172 exp: "(".concat(typeBinding, ")==='radio'") + ifConditionExtra, 25173 block: branch1 25174 }); 25175 // 3. other 25176 var branch2 = cloneASTElement(el); 25177 getAndRemoveAttr(branch2, 'v-for', true); 25178 addRawAttr(branch2, ':type', typeBinding); 25179 processElement(branch2, options); 25180 addIfCondition(branch0, { 25181 exp: ifCondition, 25182 block: branch2 25183 }); 25184 if (hasElse) { 25185 branch0.else = true; 25186 } 25187 else if (elseIfCondition) { 25188 branch0.elseif = elseIfCondition; 25189 } 25190 return branch0; 25191 } 25192 } 25193} 25194function cloneASTElement(el) { 25195 return createASTElement(el.tag, el.attrsList.slice(), el.parent); 25196} 25197var model = { 25198 preTransformNode: preTransformNode 25199}; 25200 25201var modules = [klass, style, model]; 25202 25203function text(el, dir) { 25204 if (dir.value) { 25205 addProp(el, 'textContent', "_s(".concat(dir.value, ")"), dir); 25206 } 25207} 25208 25209function html(el, dir) { 25210 if (dir.value) { 25211 addProp(el, 'innerHTML', "_s(".concat(dir.value, ")"), dir); 25212 } 25213} 25214 25215var directives = { 25216 model: model$1, 25217 text: text, 25218 html: html 25219}; 25220 25221var baseOptions = { 25222 expectHTML: true, 25223 modules: modules, 25224 directives: directives, 25225 isPreTag: isPreTag, 25226 isUnaryTag: isUnaryTag, 25227 mustUseProp: mustUseProp, 25228 canBeLeftOpenTag: canBeLeftOpenTag, 25229 isReservedTag: isReservedTag, 25230 getTagNamespace: getTagNamespace, 25231 staticKeys: genStaticKeys$1(modules) 25232}; 25233 25234var isStaticKey; 25235var isPlatformReservedTag;
25236var genStaticKeysCached = cached(genStaticKeys); 25237/** 25238 * Goal of the optimizer: walk the generated template AST tree 25239 * and detect sub-trees that are purely static, i.e. parts of 25240 * the DOM that never needs to change. 25241 * 25242 * Once we detect these sub-trees, we can: 25243 * 25244 * 1. Hoist them into constants, so that we no longer need to 25245 * create fresh nodes for them on each re-render; 25246 * 2. Completely skip them in the patching process. 25247 */ 25248function optimize(root, options) { 25249 if (!root) 25250 return; 25251 isStaticKey = genStaticKeysCached(options.staticKeys || ''); 25252 isPlatformReservedTag = options.isReservedTag || no; 25253 // first pass: mark all non-static nodes. 25254 markStatic(root); 25255 // second pass: mark static roots. 25256 markStaticRoots(root, false); 25257} 25258function genStaticKeys(keys) { 25259 return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' + 25260 (keys ? ',' + keys : '')); 25261} 25262function markStatic(node) { 25263 node.static = isStatic(node); 25264 if (node.type === 1) { 25265 // do not make component slot content static. this avoids 25266 // 1. components not able to mutate slot nodes 25267 // 2. static slot content fails for hot-reloading 25268 if (!isPlatformReservedTag(node.tag) && 25269 node.tag !== 'slot' && 25270 node.attrsMap['inline-template'] == null) { 25271 return; 25272 } 25273 for (var i = 0, l = node.children.length; i < l; i++) { 25274 var child = node.children[i]; 25275 markStatic(child); 25276 if (!child.static) { 25277 node.static = false; 25278 } 25279 } 25280 if (node.ifConditions) { 25281 for (var i = 1, l = node.ifConditions.length; i < l; i++) { 25282 var block = node.ifConditions[i].block; 25283 markStatic(block); 25284 if (!block.static) { 25285 node.static = false; 25286 } 25287 } 25288 } 25289 } 25290} 25291function markStaticRoots(node, isInFor) { 25292 if (node.type === 1) { 25293 if (node.static || node.once) { 25294 node.staticInFor = isInFor; 25295 } 25296 // For a node to qualify as a static root, it should have children that 25297 // are not just static text. Otherwise the cost of hoisting out will 25298 // outweigh the benefits and it's better off to just always render it fresh. 25299 if (node.static && 25300 node.children.length && 25301 !(node.children.length === 1 && node.children[0].type === 3)) { 25302 node.staticRoot = true; 25303 return; 25304 } 25305 else { 25306 node.staticRoot = false; 25307 } 25308 if (node.children) { 25309 for (var i = 0, l = node.children.length; i < l; i++) { 25310 markStaticRoots(node.children[i], isInFor || !!node.for); 25311 } 25312 } 25313 if (node.ifConditions) { 25314 for (var i = 1, l = node.ifConditions.length; i < l; i++) { 25315 markStaticRoots(node.ifConditions[i].block, isInFor); 25316 } 25317 } 25318 } 25319} 25320function isStatic(node) { 25321 if (node.type === 2) { 25322 // expression 25323 return false; 25324 } 25325 if (node.type === 3) { 25326 // text 25327 return true; 25328 } 25329 return !!(node.pre || 25330 (!node.hasBindings && // no dynamic bindings 25331 !node.if && 25332 !node.for && // not v-if or v-for or v-else 25333 !isBuiltInTag(node.tag) && // not a built-in 25334 isPlatformReservedTag(node.tag) && // not a component 25335 !isDirectChildOfTemplateFor(node) && 25336 Object.keys(node).every(isStaticKey))); 25337} 25338function isDirectChildOfTemplateFor(node) { 25339 while (node.parent) { 25340 node = node.parent; 25341 if (node.tag !== 'template') { 25342 return false; 25343 } 25344 if (node.for) { 25345 return true; 25346 } 25347 } 25348 return false; 25349} 25350 25351var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/; 25352var fnInvokeRE = /\([^)]*?\);*$/; 25353var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/; 25354// KeyboardEvent.keyCode aliases 25355var keyCodes = { 25356 esc: 27, 25357 tab: 9, 25358 enter: 13, 25359 space: 32, 25360 up: 38, 25361 left: 37, 25362 right: 39, 25363 down: 40, 25364 delete: [8, 46] 25365}; 25366// KeyboardEvent.key aliases 25367var keyNames = { 25368 // #7880: IE11 and Edge use `Esc` for Escape key name. 25369 esc: ['Esc', 'Escape'], 25370 tab: 'Tab', 25371 enter: 'Enter', 25372 // #9112: IE11 uses `Spacebar` for Space key name. 25373 space: [' ', 'Spacebar'], 25374 // #7806: IE11 uses key names without `Arrow` prefix for arrow keys. 25375 up: ['Up', 'ArrowUp'], 25376 left: ['Left', 'ArrowLeft'], 25377 right: ['Right', 'ArrowRight'],
25378 down: ['Down', 'ArrowDown'], 25379 // #9112: IE11 uses `Del` for Delete key name. 25380 delete: ['Backspace', 'Delete', 'Del'] 25381}; 25382// #4868: modifiers that prevent the execution of the listener 25383// need to explicitly return null so that we can determine whether to remove 25384// the listener for .once 25385var genGuard = function (condition) { return "if(".concat(condition, ")return null;"); }; 25386var modifierCode = { 25387 stop: '$event.stopPropagation();', 25388 prevent: '$event.preventDefault();', 25389 self: genGuard("$event.target !== $event.currentTarget"), 25390 ctrl: genGuard("!$event.ctrlKey"), 25391 shift: genGuard("!$event.shiftKey"), 25392 alt: genGuard("!$event.altKey"), 25393 meta: genGuard("!$event.metaKey"), 25394 left: genGuard("'button' in $event && $event.button !== 0"), 25395 middle: genGuard("'button' in $event && $event.button !== 1"), 25396 right: genGuard("'button' in $event && $event.button !== 2") 25397}; 25398function genHandlers(events, isNative) { 25399 var prefix = isNative ? 'nativeOn:' : 'on:'; 25400 var staticHandlers = ""; 25401 var dynamicHandlers = ""; 25402 for (var name_1 in events) { 25403 var handlerCode = genHandler(events[name_1]); 25404 //@ts-expect-error 25405 if (events[name_1] && events[name_1].dynamic) { 25406 dynamicHandlers += "".concat(name_1, ",").concat(handlerCode, ","); 25407 } 25408 else { 25409 staticHandlers += "\"".concat(name_1, "\":").concat(handlerCode, ","); 25410 } 25411 } 25412 staticHandlers = "{".concat(staticHandlers.slice(0, -1), "}"); 25413 if (dynamicHandlers) { 25414 return prefix + "_d(".concat(staticHandlers, ",[").concat(dynamicHandlers.slice(0, -1), "])"); 25415 } 25416 else { 25417 return prefix + staticHandlers; 25418 } 25419} 25420function genHandler(handler) { 25421 if (!handler) { 25422 return 'function(){}'; 25423 } 25424 if (Array.isArray(handler)) { 25425 return "[".concat(handler.map(function (handler) { return genHandler(handler); }).join(','), "]"); 25426 } 25427 var isMethodPath = simplePathRE.test(handler.value); 25428 var isFunctionExpression = fnExpRE.test(handler.value); 25429 var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, '')); 25430 if (!handler.modifiers) { 25431 if (isMethodPath || isFunctionExpression) { 25432 return handler.value; 25433 } 25434 return "function($event){".concat(isFunctionInvocation ? "return ".concat(handler.value) : handler.value, "}"); // inline statement 25435 } 25436 else { 25437 var code = ''; 25438 var genModifierCode = ''; 25439 var keys = []; 25440 var _loop_1 = function (key) { 25441 if (modifierCode[key]) { 25442 genModifierCode += modifierCode[key]; 25443 // left/right 25444 if (keyCodes[key]) { 25445 keys.push(key); 25446 } 25447 } 25448 else if (key === 'exact') { 25449 var modifiers_1 = handler.modifiers; 25450 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta'] 25451 .filter(function (keyModifier) { return !modifiers_1[keyModifier]; }) 25452 .map(function (keyModifier) { return "$event.".concat(keyModifier, "Key"); }) 25453 .join('||')); 25454 } 25455 else { 25456 keys.push(key); 25457 } 25458 }; 25459 for (var key in handler.modifiers) { 25460 _loop_1(key); 25461 } 25462 if (keys.length) { 25463 code += genKeyFilter(keys); 25464 } 25465 // Make sure modifiers like prevent and stop get executed after key filtering 25466 if (genModifierCode) { 25467 code += genModifierCode; 25468 } 25469 var handlerCode = isMethodPath 25470 ? "return ".concat(handler.value, ".apply(null, arguments)") 25471 : isFunctionExpression 25472 ? "return (".concat(handler.value, ").apply(null, arguments)") 25473 : isFunctionInvocation 25474 ? "return ".concat(handler.value) 25475 : handler.value; 25476 return "function($event){".concat(code).concat(handlerCode, "}"); 25477 } 25478} 25479function genKeyFilter(keys) { 25480 return ( 25481 // make sure the key filters only apply to KeyboardEvents 25482 // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake 25483 // key events that do not have keyCode property... 25484 "if(!$event.type.indexOf('key')&&" + 25485 "".concat(keys.map(genFilterCode).join('&&'), ")return null;")); 25486} 25487function genFilterCode(key) { 25488 var keyVal = parseInt(key, 10); 25489 if (keyVal) { 25490 return "$event.keyCode!==".concat(keyVal); 25491 } 25492 var keyCode = keyCodes[key]; 25493 var keyName = keyNames[key]; 25494 return ("_k($event.keyCode," + 25495 "".concat(JSON.stringify(key), ",") + 25496 "".concat(JSON.stringify(keyCode), ",") + 25497 "$event.key," + 25498 "".concat(JSON.stringify(keyName)) + 25499 ")"); 25500} 25501 25502function on(el, dir) { 25503 if (false) {} 25504 el.wrapListeners = function (code) { return "_g(".concat(code, ",").concat(dir.value, ")"); }; 25505} 25506 25507function bind(el, dir) { 25508 el.wrapData = function (code) { 25509 return "_b(".concat(code, ",'").concat(el.tag, "',").concat(dir.value, ",").concat(dir.modifiers && dir.modifiers.prop ? 'true' : 'false').concat(dir.modifiers && dir.modifiers.sync ? ',true' : '', ")"); 25510 }; 25511} 25512 25513var baseDirectives = { 25514 on: on, 25515 bind: bind, 25516 cloak: noop 25517}; 25518 25519var CodegenState = /** @class */ (function () { 25520 function CodegenState(options) { 25521 this.options = options; 25522 this.warn = options.warn || baseWarn; 25523 this.transforms = pluckModuleFunction(options.modules, 'transformCode'); 25524 this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); 25525 this.directives = extend(extend({}, baseDirectives), options.directives); 25526 var isReservedTag = options.isReservedTag || no; 25527 this.maybeComponent = function (el) { 25528 return !!el.component || !isReservedTag(el.tag); 25529 }; 25530 this.onceId = 0; 25531 this.staticRenderFns = []; 25532 this.pre = false;
25533 } 25534 return CodegenState; 25535}()); 25536function generate(ast, options) { 25537 var state = new CodegenState(options); 25538 // fix #11483, Root level <script> tags should not be rendered. 25539 var code = ast 25540 ? ast.tag === 'script' 25541 ? 'null' 25542 : genElement(ast, state) 25543 : '_c("div")'; 25544 return { 25545 render: "with(this){return ".concat(code, "}"), 25546 staticRenderFns: state.staticRenderFns 25547 }; 25548} 25549function genElement(el, state) { 25550 if (el.parent) { 25551 el.pre = el.pre || el.parent.pre; 25552 } 25553 if (el.staticRoot && !el.staticProcessed) { 25554 return genStatic(el, state); 25555 } 25556 else if (el.once && !el.onceProcessed) { 25557 return genOnce(el, state); 25558 } 25559 else if (el.for && !el.forProcessed) { 25560 return genFor(el, state); 25561 } 25562 else if (el.if && !el.ifProcessed) { 25563 return genIf(el, state); 25564 } 25565 else if (el.tag === 'template' && !el.slotTarget && !state.pre) { 25566 return genChildren(el, state) || 'void 0'; 25567 } 25568 else if (el.tag === 'slot') { 25569 return genSlot(el, state); 25570 } 25571 else { 25572 // component or element 25573 var code = void 0; 25574 if (el.component) { 25575 code = genComponent(el.component, el, state); 25576 } 25577 else { 25578 var data = void 0; 25579 var maybeComponent = state.maybeComponent(el); 25580 if (!el.plain || (el.pre && maybeComponent)) { 25581 data = genData(el, state); 25582 } 25583 var tag 25584 // check if this is a component in <script setup> 25585 = void 0; 25586 // check if this is a component in <script setup> 25587 var bindings = state.options.bindings; 25588 if (maybeComponent && bindings && bindings.__isScriptSetup !== false) { 25589 tag = checkBindingType(bindings, el.tag); 25590 } 25591 if (!tag) 25592 tag = "'".concat(el.tag, "'"); 25593 var children = el.inlineTemplate ? null : genChildren(el, state, true); 25594 code = "_c(".concat(tag).concat(data ? ",".concat(data) : '' // data 25595 ).concat(children ? ",".concat(children) : '' // children 25596 , ")"); 25597 } 25598 // module transforms 25599 for (var i = 0; i < state.transforms.length; i++) { 25600 code = state.transforms[i](el, code); 25601 } 25602 return code; 25603 } 25604} 25605function checkBindingType(bindings, key) { 25606 var camelName = camelize(key); 25607 var PascalName = capitalize(camelName); 25608 var checkType = function (type) { 25609 if (bindings[key] === type) { 25610 return key; 25611 } 25612 if (bindings[camelName] === type) { 25613 return camelName; 25614 } 25615 if (bindings[PascalName] === type) { 25616 return PascalName; 25617 } 25618 }; 25619 var fromConst = checkType("setup-const" /* BindingTypes.SETUP_CONST */) || 25620 checkType("setup-reactive-const" /* BindingTypes.SETUP_REACTIVE_CONST */); 25621 if (fromConst) { 25622 return fromConst; 25623 } 25624 var fromMaybeRef = checkType("setup-let" /* BindingTypes.SETUP_LET */) || 25625 checkType("setup-ref" /* BindingTypes.SETUP_REF */) || 25626 checkType("setup-maybe-ref" /* BindingTypes.SETUP_MAYBE_REF */); 25627 if (fromMaybeRef) { 25628 return fromMaybeRef; 25629 } 25630} 25631// hoist static sub-trees out 25632function genStatic(el, state) { 25633 el.staticProcessed = true; 25634 // Some elements (templates) need to behave differently inside of a v-pre 25635 // node. All pre nodes are static roots, so we can use this as a location to 25636 // wrap a state change and reset it upon exiting the pre node. 25637 var originalPreState = state.pre; 25638 if (el.pre) { 25639 state.pre = el.pre; 25640 } 25641 state.staticRenderFns.push("with(this){return ".concat(genElement(el, state), "}")); 25642 state.pre = originalPreState; 25643 return "_m(".concat(state.staticRenderFns.length - 1).concat(el.staticInFor ? ',true' : '', ")"); 25644} 25645// v-once 25646function genOnce(el, state) { 25647 el.onceProcessed = true; 25648 if (el.if && !el.ifProcessed) { 25649 return genIf(el, state); 25650 } 25651 else if (el.staticInFor) { 25652 var key = ''; 25653 var parent_1 = el.parent; 25654 while (parent_1) { 25655 if (parent_1.for) { 25656 key = parent_1.key; 25657 break; 25658 } 25659 parent_1 = parent_1.parent; 25660 } 25661 if (!key) { 25662 false && 25663 0; 25664 return genElement(el, state); 25665 } 25666 return "_o(".concat(genElement(el, state), ",").concat(state.onceId++, ",").concat(key, ")"); 25667 } 25668 else { 25669 return genStatic(el, state); 25670 } 25671} 25672function genIf(el, state, altGen, altEmpty) { 25673 el.ifProcessed = true; // avoid recursion 25674 return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty); 25675} 25676function genIfConditions(conditions, state, altGen, altEmpty) { 25677 if (!conditions.length) { 25678 return altEmpty || '_e()'; 25679 } 25680 var condition = conditions.shift(); 25681 if (condition.exp) { 25682 return "(".concat(condition.exp, ")?").concat(genTernaryExp(condition.block), ":").concat(genIfConditions(conditions, state, altGen, altEmpty)); 25683 } 25684 else { 25685 return "".concat(genTernaryExp(condition.block)); 25686 } 25687 // v-if with v-once should generate code like (a)?_m(0):_m(1) 25688 function genTernaryExp(el) { 25689 return altGen 25690 ? altGen(el, state) 25691 : el.once 25692 ? genOnce(el, state) 25693 : genElement(el, state); 25694 } 25695} 25696function genFor(el, state, altGen, altHelper) { 25697 var exp = el.for; 25698 var alias = el.alias; 25699 var iterator1 = el.iterator1 ? ",".concat(el.iterator1) : ''; 25700 var iterator2 = el.iterator2 ? ",".concat(el.iterator2) : ''; 25701 if (false) {} 25702 el.forProcessed = true; // avoid recursion 25703 return ("".concat(altHelper || '_l', "((").concat(exp, "),") + 25704 "function(".concat(alias).concat(iterator1).concat(iterator2, "){") + 25705 "return ".concat((altGen || genElement)(el, state)) + 25706 '})'); 25707} 25708function genData(el, state) { 25709 var data = '{'; 25710 // directives first. 25711 // directives may mutate the el's other properties before they are generated. 25712 var dirs = genDirectives(el, state); 25713 if (dirs) 25714 data += dirs + ','; 25715 // key 25716 if (el.key) { 25717 data += "key:".concat(el.key, ","); 25718 } 25719 // ref 25720 if (el.ref) { 25721 data += "ref:".concat(el.ref, ","); 25722 } 25723 if (el.refInFor) { 25724 data += "refInFor:true,"; 25725 } 25726 // pre 25727 if (el.pre) { 25728 data += "pre:true,"; 25729 } 25730 // record original tag name for components using "is" attribute 25731 if (el.component) { 25732 data += "tag:\"".concat(el.tag, "\","); 25733 } 25734 // module data generation functions 25735 for (var i = 0; i < state.dataGenFns.length; i++) { 25736 data += state.dataGenFns[i](el); 25737 } 25738 // attributes 25739 if (el.attrs) { 25740 data += "attrs:".concat(genProps(el.attrs), ","); 25741 } 25742 // DOM props 25743 if (el.props) { 25744 data += "domProps:".concat(genProps(el.props), ","); 25745 } 25746 // event handlers 25747 if (el.events) { 25748 data += "".concat(genHandlers(el.events, false), ","); 25749 } 25750 if (el.nativeEvents) { 25751 data += "".concat(genHandlers(el.nativeEvents, true), ","); 25752 } 25753 // slot target 25754 // only for non-scoped slots 25755 if (el.slotTarget && !el.slotScope) { 25756 data += "slot:".concat(el.slotTarget, ","); 25757 } 25758 // scoped slots 25759 if (el.scopedSlots) { 25760 data += "".concat(genScopedSlots(el, el.scopedSlots, state), ","); 25761 } 25762 // component v-model 25763 if (el.model) { 25764 data += "model:{value:".concat(el.model.value, ",callback:").concat(el.model.callback, ",expression:").concat(el.model.expression, "},"); 25765 } 25766 // inline-template 25767 if (el.inlineTemplate) { 25768 var inlineTemplate = genInlineTemplate(el, state); 25769 if (inlineTemplate) { 25770 data += "".concat(inlineTemplate, ","); 25771 } 25772 } 25773 data = data.replace(/,$/, '') + '}'; 25774 // v-bind dynamic argument wrap 25775 // v-bind with dynamic arguments must be applied using the same v-bind object 25776 // merge helper so that class/style/mustUseProp attrs are handled correctly. 25777 if (el.dynamicAttrs) { 25778 data = "_b(".concat(data, ",\"").concat(el.tag, "\",").concat(genProps(el.dynamicAttrs), ")"); 25779 } 25780 // v-bind data wrap 25781 if (el.wrapData) { 25782 data = el.wrapData(data); 25783 } 25784 // v-on data wrap 25785 if (el.wrapListeners) { 25786 data = el.wrapListeners(data); 25787 } 25788 return data; 25789} 25790function genDirectives(el, state) { 25791 var dirs = el.directives; 25792 if (!dirs) 25793 return; 25794 var res = 'directives:['; 25795 var hasRuntime = false;
25796 var i, l, dir, needRuntime; 25797 for (i = 0, l = dirs.length; i < l; i++) { 25798 dir = dirs[i]; 25799 needRuntime = true; 25800 var gen = state.directives[dir.name]; 25801 if (gen) { 25802 // compile-time directive that manipulates AST. 25803 // returns true if it also needs a runtime counterpart. 25804 needRuntime = !!gen(el, dir, state.warn); 25805 } 25806 if (needRuntime) { 25807 hasRuntime = true; 25808 res += "{name:\"".concat(dir.name, "\",rawName:\"").concat(dir.rawName, "\"").concat(dir.value 25809 ? ",value:(".concat(dir.value, "),expression:").concat(JSON.stringify(dir.value)) 25810 : '').concat(dir.arg ? ",arg:".concat(dir.isDynamicArg ? dir.arg : "\"".concat(dir.arg, "\"")) : '').concat(dir.modifiers ? ",modifiers:".concat(JSON.stringify(dir.modifiers)) : '', "},"); 25811 } 25812 } 25813 if (hasRuntime) { 25814 return res.slice(0, -1) + ']'; 25815 } 25816} 25817function genInlineTemplate(el, state) { 25818 var ast = el.children[0]; 25819 if (false) {} 25820 if (ast && ast.type === 1) { 25821 var inlineRenderFns = generate(ast, state.options); 25822 return "inlineTemplate:{render:function(){".concat(inlineRenderFns.render, "},staticRenderFns:[").concat(inlineRenderFns.staticRenderFns 25823 .map(function (code) { return "function(){".concat(code, "}"); }) 25824 .join(','), "]}"); 25825 } 25826} 25827function genScopedSlots(el, slots, state) { 25828 // by default scoped slots are considered "stable", this allows child 25829 // components with only scoped slots to skip forced updates from parent. 25830 // but in some cases we have to bail-out of this optimization 25831 // for example if the slot contains dynamic names, has v-if or v-for on them... 25832 var needsForceUpdate = el.for || 25833 Object.keys(slots).some(function (key) { 25834 var slot = slots[key]; 25835 return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic 25836 ); 25837 }); 25838 // #9534: if a component with scoped slots is inside a conditional branch, 25839 // it's possible for the same component to be reused but with different 25840 // compiled slot content. To avoid that, we generate a unique key based on 25841 // the generated code of all the slot contents. 25842 var needsKey = !!el.if; 25843 // OR when it is inside another scoped slot or v-for (the reactivity may be 25844 // disconnected due to the intermediate scope variable) 25845 // #9438, #9506 25846 // TODO: this can be further optimized by properly analyzing in-scope bindings 25847 // and skip force updating ones that do not actually use scope variables. 25848 if (!needsForceUpdate) { 25849 var parent_2 = el.parent; 25850 while (parent_2) { 25851 if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) || 25852 parent_2.for) { 25853 needsForceUpdate = true; 25854 break; 25855 } 25856 if (parent_2.if) { 25857 needsKey = true; 25858 } 25859 parent_2 = parent_2.parent; 25860 } 25861 } 25862 var generatedSlots = Object.keys(slots) 25863 .map(function (key) { return genScopedSlot(slots[key], state); }) 25864 .join(','); 25865 return "scopedSlots:_u([".concat(generatedSlots, "]").concat(needsForceUpdate ? ",null,true" : "").concat(!needsForceUpdate && needsKey ? ",null,false,".concat(hash(generatedSlots)) : "", ")"); 25866} 25867function hash(str) { 25868 var hash = 5381; 25869 var i = str.length; 25870 while (i) { 25871 hash = (hash * 33) ^ str.charCodeAt(--i); 25872 } 25873 return hash >>> 0; 25874} 25875function containsSlotChild(el) { 25876 if (el.type === 1) { 25877 if (el.tag === 'slot') { 25878 return true; 25879 } 25880 return el.children.some(containsSlotChild); 25881 } 25882 return false; 25883} 25884function genScopedSlot(el, state) { 25885 var isLegacySyntax = el.attrsMap['slot-scope']; 25886 if (el.if && !el.ifProcessed && !isLegacySyntax) { 25887 return genIf(el, state, genScopedSlot, "null"); 25888 } 25889 if (el.for && !el.forProcessed) { 25890 return genFor(el, state, genScopedSlot); 25891 } 25892 var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope); 25893 var fn = "function(".concat(slotScope, "){") + 25894 "return ".concat(el.tag === 'template' 25895 ? el.if && isLegacySyntax 25896 ? "(".concat(el.if, ")?").concat(genChildren(el, state) || 'undefined', ":undefined") 25897 : genChildren(el, state) || 'undefined' 25898 : genElement(el, state), "}"); 25899 // reverse proxy v-slot without scope on this.$slots 25900 var reverseProxy = slotScope ? "" : ",proxy:true"; 25901 return "{key:".concat(el.slotTarget || "\"default\"", ",fn:").concat(fn).concat(reverseProxy, "}"); 25902}
25903function genChildren(el, state, checkSkip, altGenElement, altGenNode) { 25904 var children = el.children; 25905 if (children.length) { 25906 var el_1 = children[0]; 25907 // optimize single v-for 25908 if (children.length === 1 && 25909 el_1.for && 25910 el_1.tag !== 'template' && 25911 el_1.tag !== 'slot') { 25912 var normalizationType_1 = checkSkip 25913 ? state.maybeComponent(el_1) 25914 ? ",1" 25915 : ",0" 25916 : ""; 25917 return "".concat((altGenElement || genElement)(el_1, state)).concat(normalizationType_1); 25918 } 25919 var normalizationType = checkSkip 25920 ? getNormalizationType(children, state.maybeComponent) 25921 : 0; 25922 var gen_1 = altGenNode || genNode; 25923 return "[".concat(children.map(function (c) { return gen_1(c, state); }).join(','), "]").concat(normalizationType ? ",".concat(normalizationType) : ''); 25924 } 25925} 25926// determine the normalization needed for the children array. 25927// 0: no normalization needed 25928// 1: simple normalization needed (possible 1-level deep nested array) 25929// 2: full normalization needed 25930function getNormalizationType(children, maybeComponent) { 25931 var res = 0; 25932 for (var i = 0; i < children.length; i++) { 25933 var el = children[i]; 25934 if (el.type !== 1) { 25935 continue; 25936 } 25937 if (needsNormalization(el) || 25938 (el.ifConditions && 25939 el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) { 25940 res = 2; 25941 break; 25942 } 25943 if (maybeComponent(el) || 25944 (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) { 25945 res = 1; 25946 } 25947 } 25948 return res; 25949} 25950function needsNormalization(el) { 25951 return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'; 25952} 25953function genNode(node, state) { 25954 if (node.type === 1) { 25955 return genElement(node, state); 25956 } 25957 else if (node.type === 3 && node.isComment) { 25958 return genComment(node); 25959 } 25960 else { 25961 return genText(node); 25962 } 25963} 25964function genText(text) { 25965 return "_v(".concat(text.type === 2 25966 ? text.expression // no need for () because already wrapped in _s() 25967 : transformSpecialNewlines(JSON.stringify(text.text)), ")"); 25968} 25969function genComment(comment) { 25970 return "_e(".concat(JSON.stringify(comment.text), ")"); 25971} 25972function genSlot(el, state) { 25973 var slotName = el.slotName || '"default"'; 25974 var children = genChildren(el, state); 25975 var res = "_t(".concat(slotName).concat(children ? ",function(){return ".concat(children, "}") : ''); 25976 var attrs = el.attrs || el.dynamicAttrs 25977 ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({ 25978 // slot props are camelized 25979 name: camelize(attr.name), 25980 value: attr.value, 25981 dynamic: attr.dynamic 25982 }); })) 25983 : null; 25984 var bind = el.attrsMap['v-bind']; 25985 if ((attrs || bind) && !children) { 25986 res += ",null"; 25987 } 25988 if (attrs) { 25989 res += ",".concat(attrs); 25990 } 25991 if (bind) { 25992 res += "".concat(attrs ? '' : ',null', ",").concat(bind); 25993 } 25994 return res + ')'; 25995} 25996// componentName is el.component, take it as argument to shun flow's pessimistic refinement 25997function genComponent(componentName, el, state) { 25998 var children = el.inlineTemplate ? null : genChildren(el, state, true); 25999 return "_c(".concat(componentName, ",").concat(genData(el, state)).concat(children ? ",".concat(children) : '', ")"); 26000} 26001function genProps(props) { 26002 var staticProps = ""; 26003 var dynamicProps = ""; 26004 for (var i = 0; i < props.length; i++) { 26005 var prop = props[i]; 26006 var value = transformSpecialNewlines(prop.value); 26007 if (prop.dynamic) { 26008 dynamicProps += "".concat(prop.name, ",").concat(value, ","); 26009 } 26010 else { 26011 staticProps += "\"".concat(prop.name, "\":").concat(value, ","); 26012 } 26013 } 26014 staticProps = "{".concat(staticProps.slice(0, -1), "}"); 26015 if (dynamicProps) { 26016 return "_d(".concat(staticProps, ",[").concat(dynamicProps.slice(0, -1), "])"); 26017 } 26018 else { 26019 return staticProps; 26020 } 26021} 26022// #3895, #4268 26023function transformSpecialNewlines(text) { 26024 return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029'); 26025} 26026 26027// these keywords should not appear inside expressions, but operators like 26028// typeof, instanceof and in are allowed 26029var prohibitedKeywordRE = new RegExp('\\b' + 26030 ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 26031 'super,throw,while,yield,delete,export,import,return,switch,default,' + 26032 'extends,finally,continue,debugger,function,arguments') 26033 .split(',') 26034 .join('\\b|\\b') + 26035 '\\b'); 26036// these unary operators should not be used as property/method names 26037var unaryOperatorsRE = new RegExp('\\b' + 26038 'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') + 26039 '\\s*\\([^\\)]*\\)'); 26040// strip strings in expressions 26041var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 26042// detect problematic expressions in a template 26043function detectErrors(ast, warn) { 26044 if (ast) { 26045 checkNode(ast, warn); 26046 } 26047} 26048function checkNode(node, warn) { 26049 if (node.type === 1) { 26050 for (var name_1 in node.attrsMap) { 26051 if (dirRE.test(name_1)) { 26052 var value = node.attrsMap[name_1]; 26053 if (value) { 26054 var range = node.rawAttrsMap[name_1]; 26055 if (name_1 === 'v-for') { 26056 checkFor(node, "v-for=\"".concat(value, "\""), warn, range); 26057 } 26058 else if (name_1 === 'v-slot' || name_1[0] === '#') { 26059 checkFunctionParameterExpression(value, "".concat(name_1, "=\"").concat(value, "\""), warn, range); 26060 } 26061 else if (onRE.test(name_1)) { 26062 checkEvent(value, "".concat(name_1, "=\"").concat(value, "\""), warn, range); 26063 } 26064 else { 26065 checkExpression(value, "".concat(name_1, "=\"").concat(value, "\""), warn, range); 26066 } 26067 } 26068 } 26069 } 26070 if (node.children) { 26071 for (var i = 0; i < node.children.length; i++) { 26072 checkNode(node.children[i], warn); 26073 } 26074 } 26075 } 26076 else if (node.type === 2) { 26077 checkExpression(node.expression, node.text, warn, node); 26078 } 26079} 26080function checkEvent(exp, text, warn, range) { 26081 var stripped = exp.replace(stripStringRE, ''); 26082 var keywordMatch = stripped.match(unaryOperatorsRE); 26083 if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') { 26084 warn("avoid using JavaScript unary operator as property name: " + 26085 "\"".concat(keywordMatch[0], "\" in expression ").concat(text.trim()), range); 26086 } 26087 checkExpression(exp, text, warn, range); 26088} 26089function checkFor(node, text, warn, range) { 26090 checkExpression(node.for || '', text, warn, range); 26091 checkIdentifier(node.alias, 'v-for alias', text, warn, range); 26092 checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range); 26093 checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range); 26094} 26095function checkIdentifier(ident, type, text, warn, range) { 26096 if (typeof ident === 'string') { 26097 try { 26098 new Function("var ".concat(ident, "=_")); 26099 } 26100 catch (e) { 26101 warn("invalid ".concat(type, " \"").concat(ident, "\" in expression: ").concat(text.trim()), range); 26102 } 26103 } 26104} 26105function checkExpression(exp, text, warn, range) { 26106 try { 26107 new Function("return ".concat(exp)); 26108 } 26109 catch (e) { 26110 var keywordMatch = exp 26111 .replace(stripStringRE, '') 26112 .match(prohibitedKeywordRE); 26113 if (keywordMatch) { 26114 warn("avoid using JavaScript keyword as property name: " + 26115 "\"".concat(keywordMatch[0], "\"\n Raw expression: ").concat(text.trim()), range); 26116 } 26117 else { 26118 warn("invalid expression: ".concat(e.message, " in\n\n") + 26119 " ".concat(exp, "\n\n") + 26120 " Raw expression: ".concat(text.trim(), "\n"), range); 26121 } 26122 } 26123} 26124function checkFunctionParameterExpression(exp, text, warn, range) { 26125 try { 26126 new Function(exp, ''); 26127 } 26128 catch (e) { 26129 warn("invalid function parameter expression: ".concat(e.message, " in\n\n") + 26130 " ".concat(exp, "\n\n") + 26131 " Raw expression: ".concat(text.trim(), "\n"), range); 26132 } 26133} 26134 26135var range = 2; 26136function generateCodeFrame(source, start, end) { 26137 if (start === void 0) { start = 0; } 26138 if (end === void 0) { end = source.length; } 26139 var lines = source.split(/\r?\n/); 26140 var count = 0; 26141 var res = []; 26142 for (var i = 0; i < lines.length; i++) { 26143 count += lines[i].length + 1; 26144 if (count >= start) {
26145 for (var j = i - range; j <= i + range || end > count; j++) { 26146 if (j < 0 || j >= lines.length) 26147 continue; 26148 res.push("".concat(j + 1).concat(repeat(" ", 3 - String(j + 1).length), "| ").concat(lines[j])); 26149 var lineLength = lines[j].length; 26150 if (j === i) { 26151 // push underline 26152 var pad = start - (count - lineLength) + 1; 26153 var length_1 = end > count ? lineLength - pad : end - start; 26154 res.push(" | " + repeat(" ", pad) + repeat("^", length_1)); 26155 } 26156 else if (j > i) { 26157 if (end > count) { 26158 var length_2 = Math.min(end - count, lineLength); 26159 res.push(" | " + repeat("^", length_2)); 26160 } 26161 count += lineLength + 1; 26162 } 26163 } 26164 break; 26165 } 26166 } 26167 return res.join('\n'); 26168} 26169function repeat(str, n) { 26170 var result = ''; 26171 if (n > 0) { 26172 // eslint-disable-next-line no-constant-condition 26173 while (true) { 26174 // eslint-disable-line 26175 if (n & 1) 26176 result += str; 26177 n >>>= 1; 26178 if (n <= 0) 26179 break; 26180 str += str; 26181 } 26182 } 26183 return result; 26184} 26185 26186function createFunction(code, errors) { 26187 try { 26188 return new Function(code); 26189 } 26190 catch (err) { 26191 errors.push({ err: err, code: code }); 26192 return noop; 26193 } 26194} 26195function createCompileToFunctionFn(compile) { 26196 var cache = Object.create(null); 26197 return function compileToFunctions(template, options, vm) { 26198 options = extend({}, options); 26199 var warn = options.warn || warn$2; 26200 delete options.warn; 26201 /* istanbul ignore if */ 26202 if (false) {} 26203 // check cache 26204 var key = options.delimiters 26205 ? String(options.delimiters) + template 26206 : template; 26207 if (cache[key]) { 26208 return cache[key]; 26209 } 26210 // compile 26211 var compiled = compile(template, options); 26212 // check compilation errors/tips 26213 if (false) {} 26214 // turn code into functions 26215 var res = {}; 26216 var fnGenErrors = []; 26217 res.render = createFunction(compiled.render, fnGenErrors); 26218 res.staticRenderFns = compiled.staticRenderFns.map(function (code) { 26219 return createFunction(code, fnGenErrors); 26220 }); 26221 // check function generation errors. 26222 // this should only happen if there is a bug in the compiler itself. 26223 // mostly for codegen development use 26224 /* istanbul ignore if */ 26225 if (false) {} 26226 return (cache[key] = res); 26227 }; 26228} 26229 26230function createCompilerCreator(baseCompile) { 26231 return function createCompiler(baseOptions) { 26232 function compile(template, options) { 26233 var finalOptions = Object.create(baseOptions); 26234 var errors = []; 26235 var tips = []; 26236 var warn = function (msg, range, tip) { 26237 (tip ? tips : errors).push(msg); 26238 }; 26239 if (options) { 26240 if (false) { var leadingSpaceLength_1; } 26241 // merge custom modules 26242 if (options.modules) { 26243 finalOptions.modules = (baseOptions.modules || []).concat(options.modules); 26244 } 26245 // merge custom directives 26246 if (options.directives) { 26247 finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives); 26248 } 26249 // copy other options 26250 for (var key in options) { 26251 if (key !== 'modules' && key !== 'directives') { 26252 finalOptions[key] = options[key]; 26253 } 26254 } 26255 } 26256 finalOptions.warn = warn; 26257 var compiled = baseCompile(template.trim(), finalOptions); 26258 if (false) {} 26259 compiled.errors = errors; 26260 compiled.tips = tips; 26261 return compiled; 26262 } 26263 return { 26264 compile: compile, 26265 compileToFunctions: createCompileToFunctionFn(compile) 26266 }; 26267 }; 26268} 26269 26270// `createCompilerCreator` allows creating compilers that use alternative 26271// parser/optimizer/codegen, e.g the SSR optimizing compiler. 26272// Here we just export a default compiler using the default parts. 26273var createCompiler = createCompilerCreator(function baseCompile(template, options) { 26274 var ast = parse(template.trim(), options); 26275 if (options.optimize !== false) { 26276 optimize(ast, options); 26277 } 26278 var code = generate(ast, options); 26279 return { 26280 ast: ast, 26281 render: code.render, 26282 staticRenderFns: code.staticRenderFns 26283 }; 26284}); 26285 26286var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions; 26287 26288// check whether current browser encodes a char inside attribute values 26289var div; 26290function getShouldDecode(href) { 26291 div = div || document.createElement('div'); 26292 div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>"; 26293 return div.innerHTML.indexOf(' ') > 0; 26294} 26295// #3663: IE encodes newlines inside attribute values while other browsers don't 26296var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
26297// #6828: chrome encodes content in a[href] 26298var shouldDecodeNewlinesForHref = inBrowser 26299 ? getShouldDecode(true) 26300 : false; 26301 26302var idToTemplate = cached(function (id) { 26303 var el = query(id); 26304 return el && el.innerHTML; 26305}); 26306var mount = Vue.prototype.$mount; 26307Vue.prototype.$mount = function (el, hydrating) { 26308 el = el && query(el); 26309 /* istanbul ignore if */ 26310 if (el === document.body || el === document.documentElement) { 26311 false && 26312 0; 26313 return this; 26314 } 26315 var options = this.$options; 26316 // resolve template/el and convert to render function 26317 if (!options.render) { 26318 var template = options.template; 26319 if (template) { 26320 if (typeof template === 'string') { 26321 if (template.charAt(0) === '#') { 26322 template = idToTemplate(template); 26323 /* istanbul ignore if */ 26324 if (false) {} 26325 } 26326 } 26327 else if (template.nodeType) { 26328 template = template.innerHTML; 26329 } 26330 else { 26331 if (false) {} 26332 return this; 26333 } 26334 } 26335 else if (el) { 26336 // @ts-expect-error 26337 template = getOuterHTML(el); 26338 } 26339 if (template) { 26340 /* istanbul ignore if */ 26341 if (false) {} 26342 var _a = compileToFunctions(template, { 26343 outputSourceRange: "production" !== 'production', 26344 shouldDecodeNewlines: shouldDecodeNewlines, 26345 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, 26346 delimiters: options.delimiters, 26347 comments: options.comments 26348 }, this), render = _a.render, staticRenderFns = _a.staticRenderFns; 26349 options.render = render; 26350 options.staticRenderFns = staticRenderFns; 26351 /* istanbul ignore if */ 26352 if (false) {} 26353 } 26354 } 26355 return mount.call(this, el, hydrating); 26356}; 26357/** 26358 * Get outerHTML of elements, taking care 26359 * of SVG elements in IE as well. 26360 */ 26361function getOuterHTML(el) { 26362 if (el.outerHTML) { 26363 return el.outerHTML; 26364 } 26365 else { 26366 var container = document.createElement('div'); 26367 container.appendChild(el.cloneNode(true)); 26368 return container.innerHTML; 26369 } 26370} 26371Vue.compile = compileToFunctions; 26372 26373 26374 26375 26376/***/ }), 26377 26378/***/ 5861: 26379/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 26380 26381"use strict"; 26382/* harmony export */ __webpack_require__.d(__webpack_exports__, { 26383/* harmony export */ Z: function() { return /* binding */ _asyncToGenerator; } 26384/* harmony export */ }); 26385function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { 26386 try { 26387 var info = gen[key](arg); 26388 var value = info.value; 26389 } catch (error) { 26390 reject(error); 26391 return; 26392 } 26393 if (info.done) { 26394 resolve(value); 26395 } else { 26396 Promise.resolve(value).then(_next, _throw); 26397 } 26398} 26399function _asyncToGenerator(fn) { 26400 return function () { 26401 var self = this, 26402 args = arguments; 26403 return new Promise(function (resolve, reject) { 26404 var gen = fn.apply(self, args); 26405 function _next(value) { 26406 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); 26407 } 26408 function _throw(err) { 26409 asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); 26410 } 26411 _next(undefined); 26412 }); 26413 }; 26414} 26415 26416/***/ }), 26417 26418/***/ 1180: 26419/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 26420 26421"use strict"; 26422 26423// EXPORTS 26424__webpack_require__.d(__webpack_exports__, { 26425 Z: function() { return /* binding */ _defineProperty; } 26426}); 26427 26428;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js 26429function _typeof(o) { 26430 "@babel/helpers - typeof"; 26431 26432 return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { 26433 return typeof o; 26434 } : function (o) { 26435 return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; 26436 }, _typeof(o); 26437} 26438;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js 26439 26440function toPrimitive(t, r) { 26441 if ("object" != _typeof(t) || !t) return t; 26442 var e = t[Symbol.toPrimitive]; 26443 if (void 0 !== e) { 26444 var i = e.call(t, r || "default"); 26445 if ("object" != _typeof(i)) return i; 26446 throw new TypeError("@@toPrimitive must return a primitive value."); 26447 } 26448 return ("string" === r ? String : Number)(t); 26449} 26450;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js 26451 26452 26453function toPropertyKey(t) { 26454 var i = toPrimitive(t, "string"); 26455 return "symbol" == _typeof(i) ? i : String(i); 26456} 26457;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 26458 26459function _defineProperty(obj, key, value) { 26460 key = toPropertyKey(key); 26461 if (key in obj) { 26462 Object.defineProperty(obj, key, { 26463 value: value, 26464 enumerable: true, 26465 configurable: true, 26466 writable: true 26467 }); 26468 } else { 26469 obj[key] = value; 26470 } 26471 return obj; 26472} 26473 26474/***/ }), 26475 26476/***/ 91: 26477/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 26478 26479"use strict"; 26480 26481// EXPORTS 26482__webpack_require__.d(__webpack_exports__, { 26483 Z: function() { return /* binding */ _objectWithoutProperties; } 26484}); 26485 26486;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js 26487function _objectWithoutPropertiesLoose(source, excluded) { 26488 if (source == null) return {}; 26489 var target = {}; 26490 var sourceKeys = Object.keys(source); 26491 var key, i; 26492 for (i = 0; i < sourceKeys.length; i++) { 26493 key = sourceKeys[i]; 26494 if (excluded.indexOf(key) >= 0) continue; 26495 target[key] = source[key]; 26496 } 26497 return target; 26498} 26499;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js 26500 26501function _objectWithoutProperties(source, excluded) { 26502 if (source == null) return {}; 26503 var target = _objectWithoutPropertiesLoose(source, excluded); 26504 var key, i; 26505 if (Object.getOwnPropertySymbols) { 26506 var sourceSymbolKeys = Object.getOwnPropertySymbols(source); 26507 for (i = 0; i < sourceSymbolKeys.length; i++) { 26508 key = sourceSymbolKeys[i]; 26509 if (excluded.indexOf(key) >= 0) continue; 26510 if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; 26511 target[key] = source[key]; 26512 } 26513 } 26514 return target; 26515} 26516 26517/***/ }), 26518 26519/***/ 7625: 26520/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { 26521 26522"use strict"; 26523 26524// EXPORTS 26525__webpack_require__.d(__webpack_exports__, { 26526 Z: function() { return /* binding */ _slicedToArray; } 26527}); 26528 26529;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js 26530function _arrayWithHoles(arr) { 26531 if (Array.isArray(arr)) return arr; 26532} 26533;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js 26534function _iterableToArrayLimit(r, l) { 26535 var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; 26536 if (null != t) { 26537 var e, 26538 n, 26539 i, 26540 u, 26541 a = [], 26542 f = !0, 26543 o = !1; 26544 try { 26545 if (i = (t = t.call(r)).next, 0 === l) { 26546 if (Object(t) !== t) return; 26547 f = !1; 26548 } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); 26549 } catch (r) { 26550 o = !0, n = r; 26551 } finally {
vendor: 1,521 bytes, lines 26552-26592
26552 try { 26553 if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; 26554 } finally { 26555 if (o) throw n; 26556 } 26557 } 26558 return a; 26559 } 26560} 26561;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js 26562function _arrayLikeToArray(arr, len) { 26563 if (len == null || len > arr.length) len = arr.length; 26564 for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; 26565 return arr2; 26566} 26567;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js 26568 26569function _unsupportedIterableToArray(o, minLen) { 26570 if (!o) return; 26571 if (typeof o === "string") return _arrayLikeToArray(o, minLen); 26572 var n = Object.prototype.toString.call(o).slice(8, -1); 26573 if (n === "Object" && o.constructor) n = o.constructor.name; 26574 if (n === "Map" || n === "Set") return Array.from(o); 26575 if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); 26576} 26577;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js 26578function _nonIterableRest() { 26579 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 26580} 26581;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js 26582 26583 26584 26585 26586function _slicedToArray(arr, i) { 26587 return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); 26588} 26589 26590/***/ }) 26591 26592}]);
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.