vendor: 6,453 bytes, lines 1-190
1/******/ (function(modules) { // webpackBootstrap 2/******/ // The module cache 3/******/ var installedModules = {}; 4/******/ 5/******/ // The require function 6/******/ function __webpack_require__(moduleId) { 7/******/ 8/******/ // Check if module is in cache 9/******/ if(installedModules[moduleId]) { 10/******/ return installedModules[moduleId].exports; 11/******/ } 12/******/ // Create a new module (and put it into the cache) 13/******/ var module = installedModules[moduleId] = { 14/******/ i: moduleId, 15/******/ l: false, 16/******/ exports: {} 17/******/ }; 18/******/ 19/******/ // Execute the module function 20/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 21/******/ 22/******/ // Flag the module as loaded 23/******/ module.l = true; 24/******/ 25/******/ // Return the exports of the module 26/******/ return module.exports; 27/******/ } 28/******/ 29/******/ 30/******/ // expose the modules object (__webpack_modules__) 31/******/ __webpack_require__.m = modules; 32/******/ 33/******/ // expose the module cache 34/******/ __webpack_require__.c = installedModules; 35/******/ 36/******/ // identity function for calling harmony imports with the correct context 37/******/ __webpack_require__.i = function(value) { return value; }; 38/******/ 39/******/ // define getter function for harmony exports 40/******/ __webpack_require__.d = function(exports, name, getter) { 41/******/ if(!__webpack_require__.o(exports, name)) { 42/******/ Object.defineProperty(exports, name, { 43/******/ configurable: false, 44/******/ enumerable: true, 45/******/ get: getter 46/******/ }); 47/******/ } 48/******/ }; 49/******/ 50/******/ // getDefaultExport function for compatibility with non-harmony modules 51/******/ __webpack_require__.n = function(module) { 52/******/ var getter = module && module.__esModule ? 53/******/ function getDefault() { return module['default']; } : 54/******/ function getModuleExports() { return module; }; 55/******/ __webpack_require__.d(getter, 'a', getter); 56/******/ return getter; 57/******/ }; 58/******/ 59/******/ // Object.prototype.hasOwnProperty.call 60/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 61/******/ 62/******/ // __webpack_public_path__ 63/******/ __webpack_require__.p = "./"; 64/******/ 65/******/ // Load entry module and return exports 66/******/ return __webpack_require__(__webpack_require__.s = 38); 67/******/ }) 68/************************************************************************/ 69/******/ ([ 70/* 0 */ 71/***/ (function(module, exports) { 72 73var g; 74 75// This works in non-strict mode 76g = (function() { 77 return this; 78})(); 79 80try { 81 // This works if eval is allowed (see CSP) 82 g = g || Function("return this")() || (1,eval)("this"); 83} catch(e) { 84 // This works if the window reference is available 85 if(typeof window === "object") 86 g = window; 87} 88 89// g can still be undefined, but nothing to do about it... 90// We return undefined, instead of nothing here, so it's 91// easier to handle this case. if(!global) { ...} 92 93module.exports = g; 94 95 96/***/ }), 97/* 1 */ 98/***/ (function(module, exports) { 99 100// shim for using process in browser 101var process = module.exports = {}; 102 103// cached from whatever global is present so that test runners that stub it 104// don't break things. But we need to wrap it in a try catch in case it is 105// wrapped in strict mode code which doesn't define any globals. It's inside a 106// function because try/catches deoptimize in certain engines. 107 108var cachedSetTimeout; 109var cachedClearTimeout; 110 111function defaultSetTimout() { 112 throw new Error('setTimeout has not been defined'); 113} 114function defaultClearTimeout () { 115 throw new Error('clearTimeout has not been defined'); 116} 117(function () { 118 try { 119 if (typeof setTimeout === 'function') { 120 cachedSetTimeout = setTimeout; 121 } else { 122 cachedSetTimeout = defaultSetTimout; 123 } 124 } catch (e) { 125 cachedSetTimeout = defaultSetTimout; 126 } 127 try { 128 if (typeof clearTimeout === 'function') { 129 cachedClearTimeout = clearTimeout; 130 } else { 131 cachedClearTimeout = defaultClearTimeout; 132 } 133 } catch (e) { 134 cachedClearTimeout = defaultClearTimeout; 135 } 136} ()) 137function runTimeout(fun) { 138 if (cachedSetTimeout === setTimeout) { 139 //normal enviroments in sane situations 140 return setTimeout(fun, 0); 141 } 142 // if setTimeout wasn't available but was latter defined 143 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 144 cachedSetTimeout = setTimeout; 145 return setTimeout(fun, 0); 146 } 147 try { 148 // when when somebody has screwed with setTimeout but no I.E. maddness 149 return cachedSetTimeout(fun, 0); 150 } catch(e){ 151 try { 152 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 153 return cachedSetTimeout.call(null, fun, 0); 154 } catch(e){ 155 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error 156 return cachedSetTimeout.call(this, fun, 0); 157 } 158 } 159 160 161} 162function runClearTimeout(marker) { 163 if (cachedClearTimeout === clearTimeout) { 164 //normal enviroments in sane situations 165 return clearTimeout(marker); 166 } 167 // if clearTimeout wasn't available but was latter defined 168 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 169 cachedClearTimeout = clearTimeout; 170 return clearTimeout(marker); 171 } 172 try { 173 // when when somebody has screwed with setTimeout but no I.E. maddness 174 return cachedClearTimeout(marker); 175 } catch (e){ 176 try { 177 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 178 return cachedClearTimeout.call(null, marker); 179 } catch (e){ 180 // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. 181 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 182 return cachedClearTimeout.call(this, marker); 183 } 184 } 185 186 187 188} 189var queue = []; 190var draining = false;
vendor: 4,492 bytes, lines 191-383
191var currentQueue; 192var queueIndex = -1; 193 194function cleanUpNextTick() { 195 if (!draining || !currentQueue) { 196 return; 197 } 198 draining = false; 199 if (currentQueue.length) { 200 queue = currentQueue.concat(queue); 201 } else { 202 queueIndex = -1; 203 } 204 if (queue.length) { 205 drainQueue(); 206 } 207} 208 209function drainQueue() { 210 if (draining) { 211 return; 212 } 213 var timeout = runTimeout(cleanUpNextTick); 214 draining = true; 215 216 var len = queue.length; 217 while(len) { 218 currentQueue = queue; 219 queue = []; 220 while (++queueIndex < len) { 221 if (currentQueue) { 222 currentQueue[queueIndex].run(); 223 } 224 } 225 queueIndex = -1; 226 len = queue.length; 227 } 228 currentQueue = null; 229 draining = false; 230 runClearTimeout(timeout); 231} 232 233process.nextTick = function (fun) { 234 var args = new Array(arguments.length - 1); 235 if (arguments.length > 1) { 236 for (var i = 1; i < arguments.length; i++) { 237 args[i - 1] = arguments[i]; 238 } 239 } 240 queue.push(new Item(fun, args)); 241 if (queue.length === 1 && !draining) { 242 runTimeout(drainQueue); 243 } 244}; 245 246// v8 likes predictible objects 247function Item(fun, array) { 248 this.fun = fun; 249 this.array = array; 250} 251Item.prototype.run = function () { 252 this.fun.apply(null, this.array); 253}; 254process.title = 'browser'; 255process.browser = true; 256process.env = {}; 257process.argv = []; 258process.version = ''; // empty string to avoid regexp issues 259process.versions = {}; 260 261function noop() {} 262 263process.on = noop; 264process.addListener = noop; 265process.once = noop; 266process.off = noop; 267process.removeListener = noop; 268process.removeAllListeners = noop; 269process.emit = noop; 270process.prependListener = noop; 271process.prependOnceListener = noop; 272 273process.listeners = function (name) { return [] } 274 275process.binding = function (name) { 276 throw new Error('process.binding is not supported'); 277}; 278 279process.cwd = function () { return '/' }; 280process.chdir = function (dir) { 281 throw new Error('process.chdir is not supported'); 282}; 283process.umask = function() { return 0; }; 284 285 286/***/ }), 287/* 2 */ 288/***/ (function(module, exports, __webpack_require__) { 289 290var apply = Function.prototype.apply; 291 292// DOM APIs, for completeness 293 294exports.setTimeout = function() { 295 return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); 296}; 297exports.setInterval = function() { 298 return new Timeout(apply.call(setInterval, window, arguments), clearInterval); 299}; 300exports.clearTimeout = 301exports.clearInterval = function(timeout) { 302 if (timeout) { 303 timeout.close(); 304 } 305}; 306 307function Timeout(id, clearFn) { 308 this._id = id; 309 this._clearFn = clearFn; 310} 311Timeout.prototype.unref = Timeout.prototype.ref = function() {}; 312Timeout.prototype.close = function() { 313 this._clearFn.call(window, this._id); 314}; 315 316// Does not start the time, just sets up the members needed. 317exports.enroll = function(item, msecs) { 318 clearTimeout(item._idleTimeoutId); 319 item._idleTimeout = msecs; 320}; 321 322exports.unenroll = function(item) { 323 clearTimeout(item._idleTimeoutId); 324 item._idleTimeout = -1; 325}; 326 327exports._unrefActive = exports.active = function(item) { 328 clearTimeout(item._idleTimeoutId); 329 330 var msecs = item._idleTimeout; 331 if (msecs >= 0) { 332 item._idleTimeoutId = setTimeout(function onTimeout() { 333 if (item._onTimeout) 334 item._onTimeout(); 335 }, msecs); 336 } 337}; 338 339// setimmediate attaches itself to the global object 340__webpack_require__(27); 341exports.setImmediate = setImmediate; 342exports.clearImmediate = clearImmediate; 343 344 345/***/ }), 346/* 3 */ 347/***/ (function(module, exports) { 348 349module.exports = function normalizeComponent ( 350 rawScriptExports, 351 compiledTemplate, 352 scopeId, 353 cssModules 354) { 355 var esModule 356 var scriptExports = rawScriptExports = rawScriptExports || {} 357 358 // ES6 modules interop 359 var type = typeof rawScriptExports.default 360 if (type === 'object' || type === 'function') { 361 esModule = rawScriptExports 362 scriptExports = rawScriptExports.default 363 } 364 365 // Vue.extend constructor export interop 366 var options = typeof scriptExports === 'function' 367 ? scriptExports.options 368 : scriptExports 369 370 // render functions 371 if (compiledTemplate) { 372 options.render = compiledTemplate.render 373 options.staticRenderFns = compiledTemplate.staticRenderFns 374 } 375 376 // scopedId 377 if (scopeId) { 378 options._scopeId = scopeId 379 } 380 381 // inject cssModules 382 if (cssModules) { 383 var computed = options.computed || (options.computed = {})
384 Object.keys(cssModules).forEach(function (key) { 385 var module = cssModules[key] 386 computed[key] = function () { return module } 387 }) 388 } 389 390 return { 391 esModule: esModule, 392 exports: scriptExports, 393 options: options 394 } 395} 396 397 398/***/ }), 399/* 4 */ 400/***/ (function(module, __webpack_exports__, __webpack_require__) { 401 402"use strict"; 403Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); 404/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__src_components_03_ui_infinite_scroll_infinite_scroll__ = __webpack_require__(12); 405/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__src_components_03_ui_video_player_video_player__ = __webpack_require__(22); 406/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__components_03_ui_timeline_slider_timeline_select__ = __webpack_require__(21); 407/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__src_components_03_ui_sliders_sliders__ = __webpack_require__(19); 408/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__src_components_03_ui_school_map_school_map__ = __webpack_require__(16); 409/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__src_components_03_ui_hero_hero__ = __webpack_require__(11); 410/* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__src_components_03_ui_school_tour_school_tour__ = __webpack_require__(17); 411/* harmony import */ var __WEBPACK_IMPORTED_MODULE_7__src_components_03_ui_category_dropdown_card_event__ = __webpack_require__(9); 412/* harmony import */ var __WEBPACK_IMPORTED_MODULE_8__src_components_03_ui_masonry_masonry__ = __webpack_require__(13); 413/* harmony import */ var __WEBPACK_IMPORTED_MODULE_9__src_components_03_ui_social_icons_social_icons__ = __webpack_require__(20); 414/* harmony import */ var __WEBPACK_IMPORTED_MODULE_10__src_components_03_ui_slider_timeline_slider_timeline__ = __webpack_require__(18); 415/* harmony import */ var __WEBPACK_IMPORTED_MODULE_11__src_components_03_ui_article_article__ = __webpack_require__(8); 416/* harmony import */ var __WEBPACK_IMPORTED_MODULE_12__src_components_03_ui_nav_nav__ = __webpack_require__(14); 417/* harmony import */ var __WEBPACK_IMPORTED_MODULE_13__src_components_03_ui_comments_comments__ = __webpack_require__(10); 418/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14_object_fit_images__ = __webpack_require__(26); 419/* harmony import */ var __WEBPACK_IMPORTED_MODULE_14_object_fit_images___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_14_object_fit_images__); 420/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15_vue__ = __webpack_require__(36); 421/* harmony import */ var __WEBPACK_IMPORTED_MODULE_15_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_15_vue__); 422/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16_vue_paginate__ = __webpack_require__(32); 423/* harmony import */ var __WEBPACK_IMPORTED_MODULE_16_vue_paginate___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_16_vue_paginate__); 424/* harmony import */ var __WEBPACK_IMPORTED_MODULE_17__vue_components_Maps_vue__ = __webpack_require__(28); 425/* harmony import */ var __WEBPACK_IMPORTED_MODULE_17__vue_components_Maps_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_17__vue_components_Maps_vue__); 426// ===================================== 427// main.js 428// this is our entry point for webpack 429// ===================================== 430 431__webpack_require__(23); 432// require('../components/03-ui/timeline-slider/timeline-slider'); 433// require('../components/03-ui/vertical-timeline/vertical-timeline'); 434 435 436 437 438 439 440 441 442// import mobileToggleButton from '../../src/components/03-ui/menu-burger/menu-burger'; 443 444 445 446 447 448 449 450 451// import cookiePolicyFix from '../../src/components/03-ui/cookie-policy-fix/cookie-policy-fix'; 452 453// import swipeAnimation from '../../src/components/03-ui/swipe-animation/swipe-animation'; 454 455// NPM 456 457 458 459__webpack_require__(37); 460 461 462window.Vue = __WEBPACK_IMPORTED_MODULE_15_vue___default.a; 463 464__WEBPACK_IMPORTED_MODULE_15_vue___default.a.config.productionTip = false; 465 466__WEBPACK_IMPORTED_MODULE_15_vue___default.a.use(__WEBPACK_IMPORTED_MODULE_16_vue_paginate___default.a); 467 468// Vue.component('maps', require('./vue-components/Maps.vue').default); 469 470// Import Vue Components 471// import Comments from './vue-components/Comments.vue'; 472 473 474__WEBPACK_IMPORTED_MODULE_15_vue___default.a.component('maps', __WEBPACK_IMPORTED_MODULE_17__vue_components_Maps_vue___default.a); 475 476$(document).ready(function () { 477 /* eslint-disable no-new */ 478 new __WEBPACK_IMPORTED_MODULE_15_vue___default.a({ 479 el: '#app', 480 components: { 481 // Comments, 482 Maps: __WEBPACK_IMPORTED_MODULE_17__vue_components_Maps_vue___default.a 483 } 484 }); 485 486 $(document).foundation(); 487 __WEBPACK_IMPORTED_MODULE_14_object_fit_images___default()(); 488 489 // Init Magnific Video 490 __WEBPACK_IMPORTED_MODULE_1__src_components_03_ui_video_player_video_player__["a" /* default */].init(); 491 492 // Init all Slick Sliders 493 __WEBPACK_IMPORTED_MODULE_3__src_components_03_ui_sliders_sliders__["a" /* default */].init(); 494 495 // Init Infinite Scroll 496 __WEBPACK_IMPORTED_MODULE_0__src_components_03_ui_infinite_scroll_infinite_scroll__["a" /* default */].init(); 497 498 // mobileToggleButton.init(); 499 500 __WEBPACK_IMPORTED_MODULE_11__src_components_03_ui_article_article__["a" /* default */].init(); 501 502 __WEBPACK_IMPORTED_MODULE_8__src_components_03_ui_masonry_masonry__["a" /* default */].init(); 503 504 __WEBPACK_IMPORTED_MODULE_7__src_components_03_ui_category_dropdown_card_event__["a" /* default */].init(); 505 506 __WEBPACK_IMPORTED_MODULE_2__components_03_ui_timeline_slider_timeline_select__["a" /* default */].init(); 507 508 __WEBPACK_IMPORTED_MODULE_9__src_components_03_ui_social_icons_social_icons__["a" /* default */].init(); 509 510 __WEBPACK_IMPORTED_MODULE_6__src_components_03_ui_school_tour_school_tour__["a" /* default */].init(); 511 // 512 // cookiePolicyFix.init(); 513 514 // swipeAnimation.init(); 515 516 // Init School Tour JS after Map is initialised 517 // schoolTourClick.init(); 518 519 // Init Timeline Slider 520 __WEBPACK_IMPORTED_MODULE_10__src_components_03_ui_slider_timeline_slider_timeline__["a" /* default */].init(); 521 522 __WEBPACK_IMPORTED_MODULE_12__src_components_03_ui_nav_nav__["a" /* default */].init(); 523 524 __WEBPACK_IMPORTED_MODULE_13__src_components_03_ui_comments_comments__["a" /* default */].init(); 525 526 $('.c-timeline-select li:first a').addClass('selected'); 527 $('.c-timeline-li li:first').addClass('selected'); 528 529 $('.vertical-help .events .selected').parent().addClass('active-li'); 530 531 $('.c-timeline-select li:first a').addClass('selected'); 532 $('.c-timeline-li li:first').addClass('selected'); 533 534 // if(! $(".events-wrapper").closest(".slider-event").length ) { 535 // event.preventDefault(); 536 // } 537 538 var $container = $('.portfolioContainer'); 539 $container.isotope({ 540 filter: '*', 541 animationOptions: { 542 duration: 750, 543 easing: 'linear', 544 queue: false 545 } 546 }); 547 548 $('.portfolioFilter a').click(function () { 549 $('.portfolioFilter .current').removeClass('current'); 550 $(this).addClass('current'); 551 552 var selector = $(this).attr('data-filter'); 553 $container.isotope({ 554 filter: selector, 555 animationOptions: { 556 duration: 750, 557 easing: 'linear', 558 queue: false 559 } 560 561 }); 562 return false;
563 }); 564 565 // Init ACF Map for School Tours 566 __WEBPACK_IMPORTED_MODULE_4__src_components_03_ui_school_map_school_map__["a" /* default */].init(); 567 __WEBPACK_IMPORTED_MODULE_5__src_components_03_ui_hero_hero__["a" /* default */].init(); 568}); 569 570/***/ }), 571/* 5 */ 572/***/ (function(module, exports) { 573 574// removed by extract-text-webpack-plugin 575 576/***/ }), 577/* 6 */ 578/***/ (function(module, __webpack_exports__, __webpack_require__) { 579 580"use strict"; 581Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); 582/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__vue_partials_MapCard_vue__ = __webpack_require__(29); 583/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__vue_partials_MapCard_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__vue_partials_MapCard_vue__); 584// 585// 586// 587// 588// 589// 590// 591// 592// 593// 594// 595// 596// 597// 598// 599// 600// 601// 602// 603// 604// 605// 606// 607// 608// 609// 610// 611// 612// 613// 614// 615// 616// 617// 618// 619// 620// 621// 622// 623// 624// 625// 626// 627// 628// 629// 630// 631// 632// 633// 634// 635// 636// 637// 638// 639// 640// 641// 642// 643// 644// 645// 646// 647// 648// 649// 650// 651// 652// 653// 654// 655// 656// 657// 658// 659// 660// 661// 662 663 664 665 666/* harmony default export */ __webpack_exports__["default"] = ({ 667 name: 'Maps', 668 669 props: { 670 maps: { 671 type: Array, 672 default: function _default() { 673 return maps; 674 } 675 } 676 }, 677 678 data: function data() { 679 return { 680 perPage: 6, 681 paginate: ['items'], 682 mapsList: [], 683 filteredList: [], 684 provinces: ['munster', 'leinster', 'connacht', 'ulster'], 685 selectedProvince: '' 686 }; 687 }, 688 689 690 components: { MapCard: __WEBPACK_IMPORTED_MODULE_0__vue_partials_MapCard_vue___default.a }, 691 692 computed: { 693 hasMoreItems: function hasMoreItems() { 694 return this.filteredList.length > this.perPage; 695 } 696 }, 697 698 // watch: { 699 // selectedProvince: function() { 700 // this.filterByCategory() 701 // } 702 // }, 703 704 mounted: function mounted() { 705 this.mapsList = this.maps; 706 this.filteredList = this.mapsList; 707 this.selectedProvince = "all"; 708 709 $(this.$el).foundation(); 710 this.callFoundation(); 711 712 if (Foundation.MediaQuery.current == 'medium') { 713 this.perPage = 6; 714 } 715 716 jQuery(window).on('changed.zf.mediaquery', function (event, newSize, oldSize) { 717 // newSize is the name of the now-current breakpoint, oldSize is the previous breakpoint 718 if (Foundation.MediaQuery.is('medium only')) { 719 this.perPage = 2; 720 } else if (Foundation.MediaQuery.atLeast('large')) { 721 this.perPage = 6; 722 } else { 723 this.perPage = 3; 724 } 725 }); 726 727 $('.map-filter-btn').click(function () { 728 $('#cardFilters').css("display", "none"); 729 $('#cardFilters').attr("aria-hidden", "true"); 730 $('.map-filter-accordion-parent').attr("aria-expanded", "false"); 731 }); 732 }, 733 734 735 methods: { 736 callFoundation: function callFoundation() { 737 var _this = this; 738 739 this.$nextTick(function () { 740 $(_this.$el).foundation(); 741 Foundation.reInit('equalizer'); 742 }); 743 }, 744 loadMore: function loadMore() { 745 // this.perPage = this.perPage + 3; 746 747 if (Foundation.MediaQuery.current == 'medium') { 748 this.perPage = this.perPage + 2; 749 } else if (Foundation.MediaQuery.atLeast('large')) { 750 this.perPage = this.perPage + 3; 751 } else { 752 this.perPage = this.perPage + 3; 753 } 754 755 $(window).on('changed.zf.mediaquery', function (event, newSize, oldSize) { 756 // newSize is the name of the now-current breakpoint, oldSize is the previous breakpoint 757 if (Foundation.MediaQuery.is('medium only')) { 758 this.perPage = this.perPage + 2; 759 } else if (Foundation.MediaQuery.atLeast('large')) { 760 this.perPage = this.perPage + 3; 761 } else { 762 this.perPage = this.perPage + 3; 763 } 764 }); 765 766 this.callFoundation(); 767 }, 768 setSelectedProvince: function setSelectedProvince(province) { 769 this.selectedProvince = province; 770 this.filterByCategory(); 771 }, 772 filterByCategory: function filterByCategory() { 773 var _this2 = this; 774 775 if (!this.selectedProvince) { 776 return; 777 } 778 779 if (this.selectedProvince !== 'all') { 780 781 this.filteredList = this.mapsList.filter(function (map) { 782 return map['mapProvince'] === _this2.selectedProvince; 783 }); 784 } 785 } 786 } 787}); 788 789/***/ }), 790/* 7 */ 791/***/ (function(module, __webpack_exports__, __webpack_require__) { 792 793"use strict"; 794Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); 795// 796// 797// 798// 799// 800// 801// 802// 803// 804// 805// 806// 807// 808// 809// 810// 811 812 813/* harmony default export */ __webpack_exports__["default"] = ({ 814 name: 'MapCard', 815 816 props: { 817 mapData: { 818 type: Object, 819 immediate: false 820 } 821 }, 822 823 computed: { 824 // Compute MapLink 825 mapLink: function mapLink() { 826 return "/wp-content/themes/living-history/assets/maps/index.htm?start_scene=" + this.mapData.mapLink; 827 }, 828 // Compute Image Link 829 imageLink: function imageLink() { 830 return "/wp-content/themes/living-history/assets/maps/panos/" + this.mapData.mapLink.replace("scene_", "") + ".tiles/thumb.jpg"; 831 } 832 }, 833 834 mounted: function mounted() {} 835}); 836 837/***/ }), 838/* 8 */ 839/***/ (function(module, __webpack_exports__, __webpack_require__) { 840 841"use strict"; 842var articleMasonry = {
843 init: function init() { 844 845 //************************************************* 846 // 847 // IAS & Masonry 848 // 849 //************************************************* 850 if ($('.living-history-masonry-grid').length) { 851 var iso = new Isotope('.living-history-masonry-grid', { 852 itemSelector: '.grid-item', 853 percentPosition: true, 854 masonry: { 855 columnWidth: '.grid-item' 856 } 857 }); 858 859 iso.on('layoutComplete', function (laidOutItems) { 860 // console.log( 'Masonry items laid out' ); 861 }); 862 863 var articleIas = $.ias({ 864 container: ".living-history-masonry-grid", 865 item: ".grid-item", 866 pagination: ".living-history-masonry-pagination", 867 next: ".living-history-masonry-next", 868 delay: 5 869 }); 870 871 iso.layout(); 872 873 articleIas.on('render', function (items) { 874 $(items).css({ opacity: 0 }); 875 }); 876 877 articleIas.on('rendered', function (items) { 878 iso.layout(); 879 iso.appended(items); 880 $(items).css({ opacity: 1 }); 881 }); 882 883 articleIas.on('loaded', function (data, items) { 884 var $items = $(items); 885 }); 886 887 articleIas.on('ready', function () {}); 888 889 articleIas.extension(new IASSpinnerExtension({ html: '<div class="ias-spinner" style="text-align:center"><button class="button button--loading button--action">LOADING<div class="icon-spin"><i class="icon ion-android-refresh"></i></div></button></div>' })); // shows a spinner (a.k.a. loader) 890 articleIas.extension(new IASTriggerExtension({ offset: 1, html: '<div class="text-center article-load-more u-content-c u-pb-20@small-up"><button class="ias-trigger ias-trigger-next c-button load-more-c">Load More</button></div>' })); // shows a trigger after page 3 891 articleIas.extension(new IASNoneLeftExtension({ html: '<div class="row article-load-more u-txt-c"><div class="ias-noneleft ias-noneleft-sketchbook" style="text-align:center"><p></p></div></div>' })); 892 } 893 } 894}; 895 896/* harmony default export */ __webpack_exports__["a"] = (articleMasonry); 897 898/***/ }), 899/* 9 */ 900/***/ (function(module, __webpack_exports__, __webpack_require__) { 901 902"use strict"; 903var cardEvent = { 904 init: function init() { 905 906 // Scroll to Section code for anchor links 907 $(function () { 908 $('.c-button--anchor').click(function () { 909 if (location.pathname.replace(/^\//, '') === this.pathname.replace(/^\//, '') && location.hostname === this.hostname) { 910 var target = $(this.hash); 911 target = target.length ? target : $('[name=' + this.hash.slice(1) + ']'); 912 if (target.length) { 913 $('html,body').animate({ 914 // the 230 is a fixed header offset 915 scrollTop: target.offset().top - 230 916 }, 500); 917 return false; 918 } 919 } 920 }); 921 }); 922 923 var $categoryGrid = $('.c-card-grid-categories').isotope({ 924 itemSelector: '.c-card-container', 925 layoutMode: 'masonry', 926 percentPosition: true, 927 masonry: { 928 // use outer width of grid-sizer for columnWidth 929 columnWidth: '.c-card-container' 930 } 931 }); 932 933 // bind filter button click 934 $('#cardFilters').on('click', 'a', function () { 935 var filterValue = $(this).attr('data-filter'); 936 // use filterFn if matches value 937 filterValue = filterFns[filterValue] || filterValue; 938 console.log('cardFilters working', filterValue); 939 $categoryGrid.isotope({ filter: filterValue }); 940 }); 941 942 // filter functions (required for filter to work) 943 var filterFns = {}; 944 945 $categoryGrid.isotope({ filter: '*' }); 946 947 //infiniteScroll 948 949 if ($('.mapLoad').length) { 950 // Clients IAS 951 var clientIas = jQuery.ias({ 952 container: '.mapLoad', 953 item: '.mapLoadItem', 954 pagination: '.c-pagination--mapLoad', 955 next: '.next--card' 956 }); 957 958 clientIas.extension(new IASSpinnerExtension({ html: '<div class="row large-12 u-txt-c"></div>' })); // shows a spinner (a.k.a. loader) 959 clientIas.extension(new IASTriggerExtension({ offset: 1, html: '<div class="row large-12 u-txt-c"><div class="columns small-12"><div class="c-block-button-container u-content-c u-pb-20@small-up"><button class="c-button load-more-c ias-trigger ias-trigger-next">Load More</a></div></div></div>' })); // shows a trigger after page 3 960 clientIas.extension(new IASNoneLeftExtension({ html: '<div class="row large-12 u-txt-c"><div class="columns small-12 hide">There are no more maps to load</div></div>' })); // override text when no pages left 961 962 clientIas.on('render', function (items) { 963 // console.log('Reinit'); 964 // Foundation.reInit('equalizer'); 965 }); 966 } 967 } 968}; 969 970/* harmony default export */ __webpack_exports__["a"] = (cardEvent); 971 972/***/ }), 973/* 10 */ 974/***/ (function(module, __webpack_exports__, __webpack_require__) { 975 976"use strict"; 977var Comments = {
978 init: function init() { 979 980 if ($('.c-comment-container').length) { 981 $('.c-comment-reply-link').click(function () { 982 983 // $(this).text('Cancel Reply'); 984 985 // $('.c-comment-container').find('.c-comment').removeClass('display'); 986 987 // $('.c-comment-container').find('.c-comment-reply-link').text('Cancel Reply'); 988 989 // $(this).addClass('open'); 990 // $(this).parent().siblings('.c-comment.display').removeClass('display'); 991 992 $(this).parent().siblings('.c-comment').toggleClass('display'); 993 994 $(this).text(function (i, text) { 995 return text === "Reply" ? "Cancel Reply" : "Reply"; 996 }); 997 }); 998 } 999 } 1000}; 1001 1002/* harmony default export */ __webpack_exports__["a"] = (Comments); 1003 1004/***/ }), 1005/* 11 */ 1006/***/ (function(module, __webpack_exports__, __webpack_require__) { 1007 1008"use strict"; 1009var heroVideo = { 1010 init: function init() { 1011 1012 // Smooth Scroll to anchor 1013 $(function () { 1014 $('.c-homecontent').click(function () { 1015 if (location.pathname.replace(/^\//, '') === this.pathname.replace(/^\//, '') && location.hostname === this.hostname) { 1016 var target = $(this.hash); 1017 target = target.length ? target : $('[name=' + this.hash.slice(1) + ']'); 1018 if (target.length) { 1019 $('html,body').animate({ 1020 // the 230 is a fixed header offset 1021 scrollTop: target.offset().top - 100 1022 }, 500); 1023 return false; 1024 } 1025 } 1026 }); 1027 }); 1028 1029 // Play / Pause Video 1030 var videoHomeHero = document.getElementById("hero-video-home"); 1031 // videoHomeHero.addEventListener("timeupdate", function(){ 1032 // if(this.currentTime >= 1 * 9.5) { 1033 // this.pause(); 1034 // } 1035 // }); 1036 1037 var heroVideo = document.querySelector('.c-hero--video'); 1038 1039 $('.c-hero-video-pause').click(function () { 1040 heroVideo.paused ? heroVideo.play() : heroVideo.pause(); 1041 $(this).find(".c-hero-video-pause-icon").toggleClass("paused"); 1042 }); 1043 1044 // var video = document.getElementById("hero-video-home") 1045 // 1046 // var url = "https://player.vimeo.com/external/247969742.hd.mp4?s=4770da143403523ed133125e6221284e8feba3a9&profile_id=174" 1047 // 1048 // var xhr = new XMLHttpRequest(); 1049 // xhr.open("GET", url, true); 1050 // xhr.responseType = "arraybuffer"; 1051 // 1052 // xhr.onload = function(oEvent) { 1053 // 1054 // var blob = new Blob([oEvent.target.response], {type: "video/mp4"}); 1055 // 1056 // video.src = URL.createObjectURL(blob); 1057 // video.load() 1058 // video.play() 1059 // // play on load 1060 // }; 1061 // 1062 // xhr.onprogress = function(oEvent){ 1063 // if(oEvent.lengthComputable) { 1064 // var percentComplete = oEvent.loaded/oEvent.total; 1065 // } 1066 // } 1067 // xhr.send(); 1068 } 1069}; 1070 1071/* harmony default export */ __webpack_exports__["a"] = (heroVideo); 1072 1073/***/ }), 1074/* 12 */ 1075/***/ (function(module, __webpack_exports__, __webpack_require__) { 1076 1077"use strict"; 1078 1079 1080var infiniteScroll = { 1081 init: function init() { 1082 1083 if ($('#articles').length) { 1084 // Clients IAS 1085 var articleIas = jQuery.ias({ 1086 container: '#articles', 1087 item: '.articleitem', 1088 pagination: '.c-pagination--article', 1089 next: '.next--article', 1090 delay: 800 1091 }); 1092 1093 articleIas.extension(new IASSpinnerExtension({ html: '<div class="row small-12 u-txt-c u-mt-0@small-up u-content-c u-pb-20@medium-up u-pb-20@small-up"><div class="columns small-12"><div class="c-block-button-container"><button class="c-button load-more-c ">Loading...</a></div></div></div>' })); // shows a spinner (a.k.a. loader) 1094 articleIas.extension(new IASTriggerExtension({ offset: 1, html: '<div class="text-center u-content-c u-pb-20@small-up"><a href="#" class="ias-trigger ias-trigger-next c-button load-more-c "> Load More </a></div>' })); // shows a trigger after page 3 1095 articleIas.extension(new IASNoneLeftExtension({ html: '<div class="row"><div class="columns small-12 hide">There are no more clients to load</div></div>' })); // override text when no pages left 1096 1097 articleIas.on('render', function (items) { 1098 // console.log('Reinit'); 1099 // Foundation.reInit('equalizer'); 1100 }); 1101 } 1102 } 1103}; 1104 1105/* harmony default export */ __webpack_exports__["a"] = (infiniteScroll); 1106 1107/***/ }), 1108/* 13 */ 1109/***/ (function(module, __webpack_exports__, __webpack_require__) { 1110 1111"use strict"; 1112var masonryEvent = {
1113 init: function init() { 1114 1115 var $container = $('.articles').masonry({ 1116 itemSelector: '.articleitem', 1117 columnWidth: '.articleitem', 1118 1119 percentPosition: true 1120 }); 1121 1122 // $('.item').click( function() { 1123 // $(this).remove(); 1124 // $container.masonry(); 1125 // }); 1126 1127 var $container = $('.blog').masonry({ 1128 itemSelector: '.blogitem', 1129 columnWidth: '.blogitem', 1130 percentPosition: true 1131 }); 1132 1133 setTimeout('$("#living-history-masonry-grid").css({ "visibility": "visible" })', 50); 1134 } 1135}; 1136 1137/* harmony default export */ __webpack_exports__["a"] = (masonryEvent); 1138 1139/***/ }), 1140/* 14 */ 1141/***/ (function(module, __webpack_exports__, __webpack_require__) { 1142 1143"use strict"; 1144 1145var homepageNavChange = { 1146 init: function init() { 1147 1148 if ($("#homepage-flag").length > 0) { 1149 // run code for homepage 1150 $(".c-maincontent").addClass("home"); 1151 } 1152 } 1153}; 1154 1155/* harmony default export */ __webpack_exports__["a"] = (homepageNavChange); 1156 1157/***/ }), 1158/* 15 */ 1159/***/ (function(module, __webpack_exports__, __webpack_require__) { 1160 1161"use strict"; 1162/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return icon; }); 1163/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return activeIcon; }); 1164/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return mapStyles; }); 1165/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return mapOptions; }); 1166var iconAnchor = new google.maps.Point(25, 100); 1167var iconSize = new google.maps.Size(50, 100); 1168 1169var icon = { 1170 url: '/wp-content/themes/living-history/assets/images/icons/school-tours-pin.svg', 1171 anchor: iconAnchor, 1172 scaledSize: iconSize, 1173 size: iconSize, 1174 optimize: false 1175}; 1176 1177var activeIcon = { 1178 url: '/wp-content/themes/living-history/assets/images/icons/school-tours-pin-active.svg', 1179 anchor: iconAnchor, 1180 scaledSize: iconSize, 1181 size: iconSize, 1182 optimize: false 1183}; 1184 1185var mapStyles = [{ 1186 "featureType": "all", 1187 "elementType": "labels.text.fill", 1188 "stylers": [{ 1189 "saturation": 36 1190 }, { 1191 "color": "#333333" 1192 }, { 1193 "lightness": 40 1194 }] 1195}, { 1196 "featureType": "all", 1197 "elementType": "labels.text.stroke", 1198 "stylers": [{ 1199 "visibility": "on" 1200 }, { 1201 "color": "#ffffff" 1202 }, { 1203 "lightness": 16 1204 }] 1205}, { 1206 "featureType": "all", 1207 "elementType": "labels.icon", 1208 "stylers": [{ 1209 "visibility": "off" 1210 }] 1211}, { 1212 "featureType": "administrative", 1213 "elementType": "geometry.fill", 1214 "stylers": [{ 1215 "color": "#ffffff" 1216 }, { 1217 "lightness": 20 1218 }] 1219}, { 1220 "featureType": "administrative", 1221 "elementType": "geometry.stroke", 1222 "stylers": [{ 1223 "color": "#fefefe" 1224 }, {
1225 "lightness": 17 1226 }, { 1227 "weight": 1.2 1228 }] 1229}, { 1230 "featureType": "landscape", 1231 "elementType": "geometry", 1232 "stylers": [{ 1233 "color": "#f5f4f1" 1234 }, { 1235 "lightness": 20 1236 }] 1237}, { 1238 "featureType": "poi", 1239 "elementType": "geometry", 1240 "stylers": [{ 1241 "color": "#d7d2cb" 1242 }, { 1243 "lightness": 21 1244 }] 1245}, { 1246 "featureType": "poi.park", 1247 "elementType": "geometry", 1248 "stylers": [{ 1249 "color": "#dedede" 1250 }, { 1251 "lightness": 21 1252 }] 1253}, { 1254 "featureType": "road.highway", 1255 "elementType": "geometry.fill", 1256 "stylers": [{ 1257 "color": "#e57200" 1258 }, { 1259 "lightness": 17 1260 }] 1261}, { 1262 "featureType": "road.highway", 1263 "elementType": "geometry.stroke", 1264 "stylers": [{ 1265 "color": "#6f6961" 1266 }, { 1267 "lightness": 29 1268 }, { 1269 "weight": 0.2 1270 }, { 1271 "visibility": "off" 1272 }] 1273}, { 1274 "featureType": "road.arterial", 1275 "elementType": "geometry", 1276 "stylers": [{ 1277 "color": "#d7d2cb" 1278 }, { 1279 "lightness": 18 1280 }] 1281}, { 1282 "featureType": "road.local", 1283 "elementType": "geometry", 1284 "stylers": [{ 1285 "color": "#d7d2cb" 1286 }, {
1287 "lightness": 16 1288 }] 1289}, { 1290 "featureType": "transit", 1291 "elementType": "geometry", 1292 "stylers": [{ 1293 "color": "#ffffff" 1294 }, { 1295 "lightness": 19 1296 }, { 1297 "visibility": "off" 1298 }] 1299}, { 1300 "featureType": "water", 1301 "elementType": "geometry", 1302 "stylers": [{ 1303 "color": "#6399ae" 1304 }, { 1305 "lightness": 17 1306 }] 1307}]; 1308 1309var mapOptions = { 1310 styles: mapStyles, 1311 disableDefaultUI: true, 1312 zoomControl: false, 1313 streetViewControl: false, 1314 signInControl: false, 1315 scrollwheel: false, 1316 scaleControl: false, 1317 rotateControl: false, 1318 panControl: false, 1319 mapTypeControl: false 1320}; 1321 1322/***/ }), 1323/* 16 */ 1324/***/ (function(module, __webpack_exports__, __webpack_require__) { 1325 1326"use strict"; 1327/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__school_map_helpers__ = __webpack_require__(15); 1328 1329 1330var ACFMap = { 1331 init: function init() { 1332 1333 /* 1334 * new_map 1335 * 1336 * This function will render a Google Map onto the selected jQuery element 1337 * 1338 * @type function 1339 * @date 8/11/2013 1340 * @since 4.3.0 1341 * 1342 * @param $el (jQuery element) 1343 * @return n/a 1344 */ 1345 1346 function new_map($el) { 1347 1348 // var 1349 var $markers = $el.find('.marker'); 1350 1351 // vars 1352 var args = { 1353 zoom: 16, 1354 scrollwheel: false, 1355 draggable: false, 1356 center: new google.maps.LatLng(0, 0), 1357 mapTypeId: google.maps.MapTypeId.ROADMAP, 1358 styles: __WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["a" /* mapStyles */], 1359 options: __WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["b" /* mapOptions */] 1360 }; 1361 1362 // create map 1363 var map = new google.maps.Map($el[0], args); 1364 1365 // add a markers reference 1366 map.markers = []; 1367 1368 // add markers 1369 $markers.each(function () { 1370 1371 add_marker($(this), map); 1372 }); 1373 1374 // center map 1375 center_map(map); 1376 1377 // return 1378 return map; 1379 } 1380 1381 /* 1382 * add_marker 1383 * 1384 * This function will add a marker to the selected Google Map 1385 * 1386 * @type function 1387 * @date 8/11/2013 1388 * @since 4.3.0 1389 * 1390 * @param $marker (jQuery element) 1391 * @param map (Google Map object) 1392 * @return n/a 1393 */ 1394 1395 function add_marker($marker, map) { 1396 1397 // var 1398 var latlng = new google.maps.LatLng($marker.attr('data-lat'), $marker.attr('data-lng')); 1399 1400 // create marker 1401 var marker = new google.maps.Marker({ 1402 position: latlng, 1403 map: map, 1404 icon: __WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["c" /* icon */], 1405 optimized: false 1406 }); 1407 1408 marker.metadata = { id: $marker.attr('id') 1409 1410 // add to array 1411 };map.markers.push(marker); 1412 1413 // if marker contains HTML, add it to an infoWindow 1414 if ($marker.html()) { 1415 // create info window 1416 var infowindow = new google.maps.InfoWindow({ 1417 content: $marker.html() 1418 }); 1419 1420 // show info window when marker is clicked 1421 google.maps.event.addListener(marker, 'click', function () { 1422 // infowindow.open( map, marker ); 1423 }); 1424 } 1425 1426 google.maps.event.addListener(marker, 'click', function () { 1427 $.each(map.markers, function (i, marker) { 1428 marker.setIcon(__WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["c" /* icon */]); 1429 }); 1430 1431 marker.setIcon(__WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["d" /* activeIcon */]); 1432 1433 var clickedMarkerID = this.metadata.id; 1434 var markerLoopIndex = clickedMarkerID.replace('marker-', ''); 1435 // console.log(clickedMarkerID) 1436 // console.log(markerLoopIndex) 1437 $('.c-st--list__item').removeClass('active'); 1438
1439 $("#button-" + markerLoopIndex).closest('.c-st--list__item').addClass('active'); 1440 $("#button-" + markerLoopIndex).closest('.c-st--list__item').siblings().removeClass('active'); 1441 1442 $("#content-" + markerLoopIndex).addClass('c-tour--show'); 1443 $("#content-" + markerLoopIndex).siblings().removeClass('c-tour--show'); 1444 }); 1445 1446 map.markers[0].setIcon(__WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["d" /* activeIcon */]); 1447 1448 $('#button-1').closest('.c-st--list__item').addClass('active'); 1449 1450 $('#content-1').addClass('c-tour--show'); 1451 $('#map-1').css('z-index', '10'); 1452 1453 $(".c-st--list__item button").click(function () { 1454 $(this).closest('.c-st--list__item').addClass('active'); 1455 $(this).closest('.c-st--list__item').siblings().removeClass('active'); 1456 1457 // var loopIndex = $(this).id.replace('button-', ''); 1458 var loopIndex = $(this).attr('id').replace('button-', ''); 1459 var loopIndexFromZero = loopIndex - 1; 1460 1461 // console.log(loopIndexFromZero) 1462 // console.log(loopIndex); 1463 1464 // $("#marker-" + loopIndex).css( 'z-index', '10'); 1465 // $("#marker-" + loopIndex).siblings().css( 'z-index', '0'); 1466 1467 $.each(map.markers, function (i, marker) { 1468 marker.setIcon(__WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["c" /* icon */]); 1469 }); 1470 1471 map.markers[loopIndexFromZero].setIcon(__WEBPACK_IMPORTED_MODULE_0__school_map_helpers__["d" /* activeIcon */]); 1472 1473 $("#content-" + loopIndex).addClass('c-tour--show'); 1474 $("#content-" + loopIndex).siblings().removeClass('c-tour--show'); 1475 1476 // google.maps.event.trigger(map, 'resize'); 1477 }); 1478 1479 // google.maps.event.addListener(marker, 'mouseover', function() { 1480 // marker.setIcon(activeIcon) 1481 // }); 1482 } 1483 1484 /* 1485 * center_map 1486 * 1487 * This function will center the map, showing all markers attached to this map 1488 * 1489 * @type function 1490 * @date 8/11/2013 1491 * @since 4.3.0 1492 * 1493 * @param map (Google Map object) 1494 * @return n/a 1495 */ 1496 1497 function center_map(map) { 1498 1499 // vars 1500 var bounds = new google.maps.LatLngBounds(); 1501 1502 // loop through all markers and create bounds 1503 $.each(map.markers, function (i, marker) { 1504 1505 var latlng = new google.maps.LatLng(marker.position.lat(), marker.position.lng()); 1506 1507 bounds.extend(latlng); 1508 }); 1509 1510 // only 1 marker? 1511 if (map.markers.length == 1) { 1512 // set center of map 1513 map.setCenter(bounds.getCenter()); 1514 map.setZoom(10); 1515 } else { 1516 // fit to bounds 1517 map.fitBounds(bounds); 1518 } 1519 } 1520 1521 var map = null; 1522 1523 // Create ACF Gmap Map 1524 $('.acf-map').each(function () { 1525 1526 // create map 1527 map = new_map($(this)); 1528 1529 $(".c-st--list__item button").click(function () { 1530 google.maps.event.trigger(map, 'resize'); 1531 }); 1532 }); 1533 } 1534}; 1535 1536/* harmony default export */ __webpack_exports__["a"] = (ACFMap); 1537 1538/***/ }), 1539/* 17 */ 1540/***/ (function(module, __webpack_exports__, __webpack_require__) { 1541 1542"use strict"; 1543var schoolTourClick = { 1544 init: function init() { 1545 // 1546 // $('#school-tour') 1547 // .delay(1000) 1548 // .queue(function (next) { 1549 // $(this).css('display', 'none'); 1550 // next(); 1551 // }); 1552 setTimeout('$(".c-st--list").css({ "visibility": "visible" })', 50); 1553 $(".c-st--map__container").css({ "visibility": "hidden" }); 1554 setTimeout('$(".c-st--map__container").css({ "visibility": "visible" })', 50); 1555 // if (!$('.c-tour--inner').hasClass("c-tour--show")) { 1556 // $('.c-st--map__container').css({ 'visibility': "hidden" }); 1557 // } 1558 // if ($('.c-tour--inner').hasClass("c-tour--show")) { 1559 // $('.c-st--map__container').css({ 'visibility': "visible" }); 1560 // } 1561 } 1562}; 1563 1564/* harmony default export */ __webpack_exports__["a"] = (schoolTourClick); 1565 1566/***/ }), 1567/* 18 */ 1568/***/ (function(module, __webpack_exports__, __webpack_require__) { 1569 1570"use strict"; 1571function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } 1572 1573var TimelineSlider = {
1574 init: function init() { 1575 var _$$slick; 1576 1577 // Timeline Detail Nav Slider (Do not confuse with sliders further down which are tied together to make timeline slider) 1578 var $timelineDetailSliderNav = $('.c-slider--timeline-nav--detail').slick((_$$slick = { 1579 slidesToShow: 5, 1580 slidesToScroll: 3, 1581 dots: false, 1582 arrows: true, 1583 infinite: false, 1584 autoplay: false, 1585 centerMode: false, 1586 focusOnSelect: false 1587 }, _defineProperty(_$$slick, 'centerMode', true), _defineProperty(_$$slick, 'prevArrow', '<div class="slick-prev" aria-hidden="true"><span class="ion-ios-arrow-left"></span><div>'), _defineProperty(_$$slick, 'nextArrow', '<div class="slick-next" aria-hidden="true"><span class="ion-ios-arrow-right"><div>'), _defineProperty(_$$slick, 'responsive', [{ 1588 breakpoint: 1280, 1589 settings: { 1590 slidesToShow: 5, 1591 slidesToScroll: 3 1592 } 1593 }, { 1594 breakpoint: 1024, 1595 settings: { 1596 slidesToShow: 4, 1597 slidesToScroll: 2 1598 } 1599 }, { 1600 breakpoint: 640, 1601 settings: { 1602 slidesToShow: 2, 1603 slidesToScroll: 1, 1604 arrows: true 1605 } 1606 }, { 1607 breakpoint: 450, 1608 settings: { 1609 slidesToShow: 1, 1610 slidesToScroll: 1, 1611 arrows: true 1612 } 1613 }]), _$$slick)); 1614 1615 // If Timeline Detail hook exists, check for matching slide 1616 if ($('.c-timeline-detail-hook')) { 1617 var hookID = $('.c-timeline-detail-hook').attr('id'); 1618 var slideIndex = $('.c-slider--timeline-nav--detail').find('.slick-slide#' + hookID).data('slick-index'); 1619 var classHook = $('.c-slider--timeline-nav--detail').find('.slick-slide#' + hookID); 1620 classHook.addClass("timeline-detail-active-slide"); 1621 $('.c-slider--timeline-nav--detail').slick('slickGoTo', slideIndex); 1622 } 1623 1624 /* 1625 * 1626 * Timeline Slider JS (Used for the horizontal slider on homepage) 1627 * 1628 */ 1629 1630 // Timeline Hero Slider 1631 var $timelineHeroSlider = $('.c-slider--timeline').slick({ 1632 slidesToShow: 1, 1633 slidesToScroll: 1, 1634 arrows: true, 1635 dots: false, 1636 fade: true, 1637 infinite: false, 1638 autoplay: false, 1639 adaptiveHeight: true, 1640 asNavFor: '.c-slider--timeline-nav', 1641 prevArrow: '<div class="slick-prev" aria-hidden="true"><span class="ion-ios-arrow-left"></span><div>', 1642 nextArrow: '<div class="slick-next" aria-hidden="true"><span class="ion-ios-arrow-right"><div>' 1643 }); 1644 1645 // Timeline Hero Slider Nav 1646 var $timelineHeroSliderNav = $('.c-slider--timeline-nav').slick({ 1647 slidesToShow: 5, 1648 slidesToScroll: 1, 1649 dots: false, 1650 arrows: true, 1651 infinite: false, 1652 autoplay: false, 1653 centerMode: false, 1654 focusOnSelect: false, 1655 draggable: false, 1656 // centerMode: true, 1657 // centerPadding: '60px', 1658 // asNavFor: '.c-slider--timeline', 1659 prevArrow: '<div class="slick-prev" aria-hidden="true"><span class="ion-ios-arrow-left"></span><div>', 1660 nextArrow: '<div class="slick-next" aria-hidden="true"><span class="ion-ios-arrow-right"><div>', 1661 responsive: [{ 1662 breakpoint: 1280, 1663 settings: { 1664 slidesToShow: 5 1665 } 1666 }, { 1667 breakpoint: 1024, 1668 settings: { 1669 slidesToShow: 4 1670 } 1671 }, { 1672 breakpoint: 768, 1673 settings: { 1674 centerMode: false, 1675 slidesToShow: 3, 1676 slidesToScroll: 2, 1677 arrows: true 1678 } 1679 }, { 1680 breakpoint: 640, 1681 settings: { 1682 slidesToShow: 2, 1683 slidesToScroll: 2, 1684 arrows: true, 1685 centerMode: false 1686 } 1687 }, { 1688 breakpoint: 450, 1689 settings: { 1690 centerMode: false, 1691 slidesToShow: 1, 1692 slidesToScroll: 1, 1693 arrows: true 1694 // asNavFor: '.c-slider--timeline', 1695 } 1696 }] 1697 }); 1698 1699 /* 1700 * On before slide change check both timeline sliders and add the appropriate active styles, 1701 * based on where the content portion of the slider is. 1702 */ 1703 $('.c-slider--timeline').on('afterChange', function (event, slick, currentSlide, nextSlide) { 1704 // Activating era slides based on content slide 1705 // debugger; 1706 1707 if ($('.c-slider--timeline').find(".c-slider__slide.slick-current.slick-active")) { 1708 var idMatch = $('.c-slider--timeline').find(".c-slider__slide.slick-current.slick-active").attr('id'); 1709 idMatch = idMatch.replace("timelineSlider-", ""); 1710 idMatch = "navSlider-" + idMatch; 1711 $('#' + idMatch).addClass("prev-active-slide last"); 1712 $('#' + idMatch).prevAll().addClass("prev-active-slide").removeClass("last"); 1713 $('#' + idMatch).nextAll().removeClass("prev-active-slide last"); 1714 } 1715 }); 1716 1717 // Tying the two sliders together for the timeline 1718 $timelineHeroSliderNav.find('.slick-slide').on('click', function () { 1719 var $this = $(this); 1720 1721 var index = $this.attr('data-slick-index'); 1722 1723 $timelineHeroSlider.slick('slickGoTo', index); 1724 }); 1725 1726 /* 1727 * Swipe Banner 1728 */ 1729 1730 // Checking to see if swipe banner is present 1731 if ($('.c-swipe-to-see-more.display')) { 1732 // Removing Swipe banner on swipe 1733 $('.c-slider--timeline').on('swipe', function (event, slick, direction) { 1734 $('.c-swipe-to-see-more').removeClass("display"); 1735 }); 1736 1737 // Removing swipe banner on any change 1738 $('.c-slider--timeline').on('afterChange', function (event, slick, currentSlide, nextSlide) { 1739 $('.c-swipe-to-see-more').removeClass("display"); 1740 }); 1741 } 1742 1743 if ($('.c-slider--timeline-nav').hasClass('slick-initialized')) { 1744 $('.c-slider--timeline__heading').css({ 'visibility': "visible" }); 1745 $('.c-slider--timeline__intro').css({ 'visibility': "visible" }); 1746 } 1747 } 1748}; 1749 1750/* harmony default export */ __webpack_exports__["a"] = (TimelineSlider); 1751 1752/***/ }), 1753/* 19 */ 1754/***/ (function(module, __webpack_exports__, __webpack_require__) { 1755 1756"use strict"; 1757var slickSliders = {
1758 init: function init() { 1759 1760 // slideblock Slider Settings 1761 $('.c-slider--slideblock').slick({ 1762 dots: true, 1763 infinite: true, 1764 autoplay: false, 1765 adaptiveHeight: true, 1766 arrows: true, 1767 verticalSwiping: false, 1768 prevArrow: "<div class='slick-prev c-slider-button--mobile' aria-hidden='true'><span class='ion-ios-arrow-left'></span><div>", 1769 nextArrow: "<div class='slick-next c-slider-button--mobile' aria-hidden='true'><span class='ion-ios-arrow-right'></span><div>" 1770 }); 1771 } 1772}; 1773 1774/* harmony default export */ __webpack_exports__["a"] = (slickSliders); 1775 1776/***/ }), 1777/* 20 */ 1778/***/ (function(module, __webpack_exports__, __webpack_require__) { 1779 1780"use strict"; 1781var socialIconEvents = { 1782 init: function init() { 1783 // $.fn.customerPopup = function (e, intWidth, intHeight, blnResize) { 1784 1785 // // Prevent default anchor event 1786 // e.preventDefault(); 1787 1788 // // Set values for window 1789 // intWidth = intWidth || '500'; 1790 // intHeight = intHeight || '400'; 1791 // strResize = (blnResize ? 'yes' : 'no'); 1792 1793 // // Set title and open popup with focus on it 1794 // var strTitle = ((typeof this.attr('title') !== 'undefined') ? this.attr('title') : 'Social Share'), 1795 // strParam = 'width=' + intWidth + ',height=' + intHeight + ',resizable=' + strResize, 1796 // objWindow = window.open(this.attr('href'), strTitle, strParam).focus(); 1797 // } 1798 1799 // /* ================================================== */ 1800 1801 1802 // $('.customer.share').on("click", function(e) { 1803 // $(this).customerPopup(e); 1804 // }); 1805 1806 1807 // var fbButton = document.getElementById('fb-share-button'); 1808 // var url = window.location.href; 1809 1810 // fbButton.addEventListener('click', function() { 1811 // window.open('https://www.facebook.com/sharer/sharer.php?u=' + url, 1812 // '', 1813 // 'width=800,height=600' 1814 // ); 1815 // return false; 1816 // }); 1817 1818 1819 } 1820}; 1821 1822/* harmony default export */ __webpack_exports__["a"] = (socialIconEvents); 1823 1824/***/ }), 1825/* 21 */ 1826/***/ (function(module, __webpack_exports__, __webpack_require__) { 1827 1828"use strict"; 1829var timelineSelect = { 1830 init: function init() { 1831 // $('ol.timeline-item li:first').addClass('selected'); 1832 1833 // $('.c-timeline-select li:first').addClass('selected'); 1834 1835 } 1836}; 1837 1838/* harmony default export */ __webpack_exports__["a"] = (timelineSelect); 1839 1840/***/ }), 1841/* 22 */ 1842/***/ (function(module, __webpack_exports__, __webpack_require__) { 1843 1844"use strict"; 1845var magnificVideo = { 1846 init: function init() { 1847 // $(".c-playbtn").click(function(){ 1848 // $(".c-videoplayer").show(); 1849 // $(".c-videoplayer--image").hide(); 1850 // var vidPlayer= $(".c-videoplayer"); 1851 // vidPlayer.attr("src", vidPlayer.attr("src")+"?autoplay=1"); 1852 // }); 1853 1854 // $(".cardLoad .cardLoadItem").slice(0, 6).addClass('display'); 1855 // $("#loadMore").on('click', function (e) { 1856 // e.preventDefault(); 1857 // $(".cardLoad .cardLoadItem:hidden").slice(0, 4).addClass('display'); 1858 // if ($(".cardLoad .cardLoadItem:hidden").length == 0) { 1859 // $("#load").fadeOut('slow'); 1860 // } 1861 // }); 1862 1863 if ($('.cardLoad').length) { 1864 // Clients IAS 1865 var clientIas = jQuery.ias({ 1866 container: '.cardLoad', 1867 item: '.cardLoadItem', 1868 pagination: '.c-pagination--cardLoad', 1869 next: '.next--card', 1870 delay: 800 1871 }); 1872 1873 clientIas.extension(new IASSpinnerExtension({ html: '<div class="row small-12 u-txt-c u-mt-0@small-up u-content-c u-pb-20@medium-up u-pb-20@small-up"><div class="columns small-12"><div class="c-block-button-container"><button class="c-button load-more-c ">Loading...</a></div></div></div>' })); // shows a spinner (a.k.a. loader) 1874 clientIas.extension(new IASTriggerExtension({ offset: 1, html: '<div class="row small-12 u-txt-c u-mt-0@small-up u-content-c u-pb-20@medium-up u-pb-20@small-up"><div class="columns small-12"><div class="c-block-button-container"><button class="c-button load-more-c ias-trigger ias-trigger-next">Load More</a></div></div></div>' })); // shows a trigger after page 3 1875 clientIas.extension(new IASNoneLeftExtension({ html: '<div class="row large-12 u-txt-c"><div class="columns small-12 hide">There are no more videos to load</div></div>' })); // override text when no pages left 1876 1877 clientIas.on('render', function (items) { 1878 // console.log('Reinit'); 1879 // Foundation.reInit('equalizer'); 1880 }); 1881 1882 clientIas.on('rendered', function (items) { 1883 $('.magnific').magnificPopup({ 1884 type: 'iframe' 1885 }); 1886 }); 1887 } 1888 1889 // var list = $(".cardLoad .cardLoadItem"); 1890 // var numToShow = 6; 1891 // var button = $("#loadMore"); 1892 // var numInList = list.length; 1893 // list.hide(); 1894 // if (numInList >
1894 numToShow) { 1895 // button.show(); 1896 // } 1897 // list.slice(0, numToShow).show(); 1898 // 1899 // button.click(function(){ 1900 // var showing = list.filter(':visible').length; 1901 // list.slice(showing - 1, showing + numToShow).fadeIn(); 1902 // var nowShowing = list.filter(':visible').length; 1903 // if (nowShowing >= numInList) { 1904 // button.hide(); 1905 // } 1906 // }); 1907 //--------------------- VIDEO FIT JS --------------------// 1908 var i = 0; 1909 for (i = 0; i < 5; i++) { 1910 if (window.innerWidth > 639 && window.innerWidth < 1023) { 1911 1912 $('#video-' + i).height($('#videotext-' + i).outerHeight(true)); 1913 } 1914 } 1915 1916 //--------------------- VIDEO FIT JS --------------------// 1917 $(".js-fitvideo").fitVids(); 1918 1919 $(".c-video__image-container").one('click', function () { 1920 // $(this).find(".c-video__play-btn-container").addClass("hide"); 1921 console.log($(this)); 1922 console.log($(this).attr('id')); 1923 var $myFrame = $(this).find('.c-video-reveal'); 1924 var url = $($myFrame).attr('src') + '?rel=&autoplay=1'; 1925 $($myFrame).attr('src', url); 1926 }); 1927 1928 $('.magnific').magnificPopup({ 1929 type: 'iframe' 1930 }); 1931 } 1932}; 1933 1934/* harmony default export */ __webpack_exports__["a"] = (magnificVideo); 1935 1936/***/ }), 1937/* 23 */ 1938/***/ (function(module, exports) { 1939 1940// =================================== 1941// Bootstrap file - initial JS setup 1942// =================================== 1943 1944/***/ }), 1945/* 24 */ 1946/***/ (function(module, exports, __webpack_require__) { 1947 1948exports = module.exports = __webpack_require__(25)(); 1949exports.push([module.i, "\n.text-above-dropdown {\n\tmargin-bottom: 16px !important;\n}\n.c-cat-dropdown__header {\n\tborder-bottom: 1px solid #d2d2d2;\n}\n.map-header-section {\n\tmargin-bottom: 0 !important;\n}\n", ""]); 1950 1951/***/ }), 1952/* 25 */ 1953/***/ (function(module, exports) { 1954 1955/* 1956 MIT License http://www.opensource.org/licenses/mit-license.php 1957 Author Tobias Koppers @sokra 1958*/ 1959// css base code, injected by the css-loader 1960module.exports = function() { 1961 var list = []; 1962 1963 // return the list of modules as css string 1964 list.toString = function toString() { 1965 var result = []; 1966 for(var i = 0; i < this.length; i++) { 1967 var item = this[i]; 1968 if(item[2]) { 1969 result.push("@media " + item[2] + "{" + item[1] + "}"); 1970 } else { 1971 result.push(item[1]); 1972 } 1973 } 1974 return result.join(""); 1975 }; 1976 1977 // import a list of modules into the list 1978 list.i = function(modules, mediaQuery) { 1979 if(typeof modules === "string") 1980 modules = [[null, modules, ""]]; 1981 var alreadyImportedModules = {}; 1982 for(var i = 0; i < this.length; i++) { 1983 var id = this[i][0]; 1984 if(typeof id === "number") 1985 alreadyImportedModules[id] = true; 1986 } 1987 for(i = 0; i < modules.length; i++) { 1988 var item = modules[i]; 1989 // skip already imported module 1990 // this implementation is not 100% perfect for weird media query combinations 1991 // when a module is imported multiple times with different media queries. 1992 // I hope this will never occur (Hey this way we have smaller bundles) 1993 if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) { 1994 if(mediaQuery && !item[2]) { 1995 item[2] = mediaQuery; 1996 } else if(mediaQuery) { 1997 item[2] = "(" + item[2] + ") and (" + mediaQuery + ")"; 1998 } 1999 list.push(item); 2000 } 2001 } 2002 }; 2003 return list; 2004}; 2005 2006 2007/***/ }), 2008/* 26 */ 2009/***/ (function(module, exports, __webpack_require__) { 2010 2011"use strict"; 2012/*! npm.im/object-fit-images 3.2.3 */ 2013 2014 2015var OFI = 'bfred-it:object-fit-images'; 2016var propRegex = /(object-fit|object-position)\s*:\s*([-\w\s%]+)/g; 2017var testImg = typeof Image === 'undefined' ? {style: {'object-position': 1}} : new Image(); 2018var supportsObjectFit = 'object-fit' in testImg.style; 2019var supportsObjectPosition = 'object-position' in testImg.style; 2020var supportsOFI = 'background-size' in testImg.style; 2021var supportsCurrentSrc = typeof testImg.currentSrc === 'string'; 2022var nativeGetAttribute = testImg.getAttribute; 2023var nativeSetAttribute = testImg.setAttribute; 2024var autoModeEnabled = false; 2025 2026function createPlaceholder(w, h) { 2027 return ("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='" + w + "' height='" + h + "'%3E%3C/svg%3E"); 2028} 2029 2030function polyfillCurrentSrc(el) { 2031 if (el.srcset && !supportsCurrentSrc && window.picturefill) { 2032 var pf = window.picturefill._; 2033 // parse srcset with picturefill where currentSrc isn't available 2034 if (!el[pf.ns] || !el[pf.ns].evaled) { 2035 // force synchronous srcset parsing 2036 pf.fillImg(el, {reselect: true}); 2037 } 2038 2039 if (!el[pf.ns].curSrc) { 2040 // force picturefill to parse srcset 2041 el[pf.ns].supported = false;
vendor: 4,111 bytes, lines 2042-2181
2042 pf.fillImg(el, {reselect: true}); 2043 } 2044 2045 // retrieve parsed currentSrc, if any 2046 el.currentSrc = el[pf.ns].curSrc || el.src; 2047 } 2048} 2049 2050function getStyle(el) { 2051 var style = getComputedStyle(el).fontFamily; 2052 var parsed; 2053 var props = {}; 2054 while ((parsed = propRegex.exec(style)) !== null) { 2055 props[parsed[1]] = parsed[2]; 2056 } 2057 return props; 2058} 2059 2060function setPlaceholder(img, width, height) { 2061 // Default: fill width, no height 2062 var placeholder = createPlaceholder(width || 1, height || 0); 2063 2064 // Only set placeholder if it's different 2065 if (nativeGetAttribute.call(img, 'src') !== placeholder) { 2066 nativeSetAttribute.call(img, 'src', placeholder); 2067 } 2068} 2069 2070function onImageReady(img, callback) { 2071 // naturalWidth is only available when the image headers are loaded, 2072 // this loop will poll it every 100ms. 2073 if (img.naturalWidth) { 2074 callback(img); 2075 } else { 2076 setTimeout(onImageReady, 100, img, callback); 2077 } 2078} 2079 2080function fixOne(el) { 2081 var style = getStyle(el); 2082 var ofi = el[OFI]; 2083 style['object-fit'] = style['object-fit'] || 'fill'; // default value 2084 2085 // Avoid running where unnecessary, unless OFI had already done its deed 2086 if (!ofi.img) { 2087 // fill is the default behavior so no action is necessary 2088 if (style['object-fit'] === 'fill') { 2089 return; 2090 } 2091 2092 // Where object-fit is supported and object-position isn't (Safari < 10) 2093 if ( 2094 !ofi.skipTest && // unless user wants to apply regardless of browser support 2095 supportsObjectFit && // if browser already supports object-fit 2096 !style['object-position'] // unless object-position is used 2097 ) { 2098 return; 2099 } 2100 } 2101 2102 // keep a clone in memory while resetting the original to a blank 2103 if (!ofi.img) { 2104 ofi.img = new Image(el.width, el.height); 2105 ofi.img.srcset = nativeGetAttribute.call(el, "data-ofi-srcset") || el.srcset; 2106 ofi.img.src = nativeGetAttribute.call(el, "data-ofi-src") || el.src; 2107 2108 // preserve for any future cloneNode calls 2109 // https://github.com/bfred-it/object-fit-images/issues/53 2110 nativeSetAttribute.call(el, "data-ofi-src", el.src); 2111 if (el.srcset) { 2112 nativeSetAttribute.call(el, "data-ofi-srcset", el.srcset); 2113 } 2114 2115 setPlaceholder(el, el.naturalWidth || el.width, el.naturalHeight || el.height); 2116 2117 // remove srcset because it overrides src 2118 if (el.srcset) { 2119 el.srcset = ''; 2120 } 2121 try { 2122 keepSrcUsable(el); 2123 } catch (err) { 2124 if (window.console) { 2125 console.warn('https://bit.ly/ofi-old-browser'); 2126 } 2127 } 2128 } 2129 2130 polyfillCurrentSrc(ofi.img); 2131 2132 el.style.backgroundImage = "url(\"" + ((ofi.img.currentSrc || ofi.img.src).replace(/"/g, '\\"')) + "\")"; 2133 el.style.backgroundPosition = style['object-position'] || 'center'; 2134 el.style.backgroundRepeat = 'no-repeat'; 2135 el.style.backgroundOrigin = 'content-box'; 2136 2137 if (/scale-down/.test(style['object-fit'])) { 2138 onImageReady(ofi.img, function () { 2139 if (ofi.img.naturalWidth > el.width || ofi.img.naturalHeight > el.height) { 2140 el.style.backgroundSize = 'contain'; 2141 } else { 2142 el.style.backgroundSize = 'auto'; 2143 } 2144 }); 2145 } else { 2146 el.style.backgroundSize = style['object-fit'].replace('none', 'auto').replace('fill', '100% 100%'); 2147 } 2148 2149 onImageReady(ofi.img, function (img) { 2150 setPlaceholder(el, img.naturalWidth, img.naturalHeight); 2151 }); 2152} 2153 2154function keepSrcUsable(el) { 2155 var descriptors = { 2156 get: function get(prop) { 2157 return el[OFI].img[prop ? prop : 'src']; 2158 }, 2159 set: function set(value, prop) { 2160 el[OFI].img[prop ? prop : 'src'] = value; 2161 nativeSetAttribute.call(el, ("data-ofi-" + prop), value); // preserve for any future cloneNode 2162 fixOne(el); 2163 return value; 2164 } 2165 }; 2166 Object.defineProperty(el, 'src', descriptors); 2167 Object.defineProperty(el, 'currentSrc', { 2168 get: function () { return descriptors.get('currentSrc'); } 2169 }); 2170 Object.defineProperty(el, 'srcset', { 2171 get: function () { return descriptors.get('srcset'); }, 2172 set: function (ss) { return descriptors.set(ss, 'srcset'); } 2173 }); 2174} 2175 2176function hijackAttributes() { 2177 function getOfiImageMaybe(el, name) { 2178 return el[OFI] && el[OFI].img && (name === 'src' || name === 'srcset') ? el[OFI].img : el; 2179 } 2180 if (!supportsObjectPosition) { 2181 HTMLImageElement.prototype.getAttribute = function (name) {
2182 return nativeGetAttribute.call(getOfiImageMaybe(this, name), name); 2183 }; 2184 2185 HTMLImageElement.prototype.setAttribute = function (name, value) { 2186 return nativeSetAttribute.call(getOfiImageMaybe(this, name), name, String(value)); 2187 }; 2188 } 2189} 2190 2191function fix(imgs, opts) { 2192 var startAutoMode = !autoModeEnabled && !imgs; 2193 opts = opts || {}; 2194 imgs = imgs || 'img'; 2195 2196 if ((supportsObjectPosition && !opts.skipTest) || !supportsOFI) { 2197 return false; 2198 } 2199 2200 // use imgs as a selector or just select all images 2201 if (imgs === 'img') { 2202 imgs = document.getElementsByTagName('img'); 2203 } else if (typeof imgs === 'string') { 2204 imgs = document.querySelectorAll(imgs); 2205 } else if (!('length' in imgs)) { 2206 imgs = [imgs]; 2207 } 2208 2209 // apply fix to all 2210 for (var i = 0; i < imgs.length; i++) { 2211 imgs[i][OFI] = imgs[i][OFI] || { 2212 skipTest: opts.skipTest 2213 }; 2214 fixOne(imgs[i]); 2215 } 2216 2217 if (startAutoMode) { 2218 document.body.addEventListener('load', function (e) { 2219 if (e.target.tagName === 'IMG') { 2220 fix(e.target, { 2221 skipTest: opts.skipTest 2222 }); 2223 } 2224 }, true); 2225 autoModeEnabled = true; 2226 imgs = 'img'; // reset to a generic selector for watchMQ 2227 } 2228 2229 // if requested, watch media queries for object-fit change 2230 if (opts.watchMQ) { 2231 window.addEventListener('resize', fix.bind(null, imgs, { 2232 skipTest: opts.skipTest 2233 })); 2234 } 2235} 2236 2237fix.supportsObjectFit = supportsObjectFit; 2238fix.supportsObjectPosition = supportsObjectPosition; 2239 2240hijackAttributes(); 2241 2242module.exports = fix; 2243 2244 2245/***/ }), 2246/* 27 */ 2247/***/ (function(module, exports, __webpack_require__) { 2248 2249/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) { 2250 "use strict"; 2251 2252 if (global.setImmediate) { 2253 return; 2254 } 2255 2256 var nextHandle = 1; // Spec says greater than zero 2257 var tasksByHandle = {}; 2258 var currentlyRunningATask = false; 2259 var doc = global.document; 2260 var registerImmediate; 2261 2262 function setImmediate(callback) { 2263 // Callback can either be a function or a string 2264 if (typeof callback !== "function") { 2265 callback = new Function("" + callback); 2266 } 2267 // Copy function arguments 2268 var args = new Array(arguments.length - 1); 2269 for (var i = 0; i < args.length; i++) { 2270 args[i] = arguments[i + 1]; 2271 } 2272 // Store and register the task 2273 var task = { callback: callback, args: args }; 2274 tasksByHandle[nextHandle] = task; 2275 registerImmediate(nextHandle); 2276 return nextHandle++; 2277 } 2278 2279 function clearImmediate(handle) { 2280 delete tasksByHandle[handle]; 2281 } 2282 2283 function run(task) { 2284 var callback = task.callback; 2285 var args = task.args; 2286 switch (args.length) { 2287 case 0: 2288 callback(); 2289 break; 2290 case 1: 2291 callback(args[0]); 2292 break; 2293 case 2: 2294 callback(args[0], args[1]); 2295 break; 2296 case 3: 2297 callback(args[0], args[1], args[2]); 2298 break; 2299 default: 2300 callback.apply(undefined, args); 2301 break; 2302 } 2303 } 2304 2305 function runIfPresent(handle) { 2306 // From the spec: "Wait until any invocations of this algorithm started before this one have completed." 2307 // So if we're currently running a task, we'll need to delay this invocation. 2308 if (currentlyRunningATask) { 2309 // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a 2310 // "too much recursion" error. 2311 setTimeout(runIfPresent, 0, handle); 2312 } else { 2313 var task = tasksByHandle[handle]; 2314 if (task) { 2315 currentlyRunningATask = true; 2316 try { 2317 run(task); 2318 } finally { 2319 clearImmediate(handle); 2320 currentlyRunningATask = false; 2321 } 2322 } 2323 } 2324 } 2325 2326 function installNextTickImplementation() { 2327 registerImmediate = function(handle) { 2328 process.nextTick(function () { runIfPresent(handle); }); 2329 }; 2330 } 2331 2332 function canUsePostMessage() { 2333 // The test against `importScripts` prevents this implementation from being installed inside a web worker,
vendor: 4,484 bytes, lines 2334-2457
2334 // where `global.postMessage` means something completely different and can't be used for this purpose. 2335 if (global.postMessage && !global.importScripts) { 2336 var postMessageIsAsynchronous = true; 2337 var oldOnMessage = global.onmessage; 2338 global.onmessage = function() { 2339 postMessageIsAsynchronous = false; 2340 }; 2341 global.postMessage("", "*"); 2342 global.onmessage = oldOnMessage; 2343 return postMessageIsAsynchronous; 2344 } 2345 } 2346 2347 function installPostMessageImplementation() { 2348 // Installs an event handler on `global` for the `message` event: see 2349 // * https://developer.mozilla.org/en/DOM/window.postMessage 2350 // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages 2351 2352 var messagePrefix = "setImmediate$" + Math.random() + "$"; 2353 var onGlobalMessage = function(event) { 2354 if (event.source === global && 2355 typeof event.data === "string" && 2356 event.data.indexOf(messagePrefix) === 0) { 2357 runIfPresent(+event.data.slice(messagePrefix.length)); 2358 } 2359 }; 2360 2361 if (global.addEventListener) { 2362 global.addEventListener("message", onGlobalMessage, false); 2363 } else { 2364 global.attachEvent("onmessage", onGlobalMessage); 2365 } 2366 2367 registerImmediate = function(handle) { 2368 global.postMessage(messagePrefix + handle, "*"); 2369 }; 2370 } 2371 2372 function installMessageChannelImplementation() { 2373 var channel = new MessageChannel(); 2374 channel.port1.onmessage = function(event) { 2375 var handle = event.data; 2376 runIfPresent(handle); 2377 }; 2378 2379 registerImmediate = function(handle) { 2380 channel.port2.postMessage(handle); 2381 }; 2382 } 2383 2384 function installReadyStateChangeImplementation() { 2385 var html = doc.documentElement; 2386 registerImmediate = function(handle) { 2387 // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted 2388 // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called. 2389 var script = doc.createElement("script"); 2390 script.onreadystatechange = function () { 2391 runIfPresent(handle); 2392 script.onreadystatechange = null; 2393 html.removeChild(script); 2394 script = null; 2395 }; 2396 html.appendChild(script); 2397 }; 2398 } 2399 2400 function installSetTimeoutImplementation() { 2401 registerImmediate = function(handle) { 2402 setTimeout(runIfPresent, 0, handle); 2403 }; 2404 } 2405 2406 // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live. 2407 var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global); 2408 attachTo = attachTo && attachTo.setTimeout ? attachTo : global; 2409 2410 // Don't get fooled by e.g. browserify environments. 2411 if ({}.toString.call(global.process) === "[object process]") { 2412 // For Node.js before 0.9 2413 installNextTickImplementation(); 2414 2415 } else if (canUsePostMessage()) { 2416 // For non-IE10 modern browsers 2417 installPostMessageImplementation(); 2418 2419 } else if (global.MessageChannel) { 2420 // For web workers, where supported 2421 installMessageChannelImplementation(); 2422 2423 } else if (doc && "onreadystatechange" in doc.createElement("script")) { 2424 // For IE 6–8 2425 installReadyStateChangeImplementation(); 2426 2427 } else { 2428 // For older browsers 2429 installSetTimeoutImplementation(); 2430 } 2431 2432 attachTo.setImmediate = setImmediate; 2433 attachTo.clearImmediate = clearImmediate; 2434}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self)); 2435 2436/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(1))) 2437 2438/***/ }), 2439/* 28 */ 2440/***/ (function(module, exports, __webpack_require__) { 2441 2442 2443/* styles */ 2444__webpack_require__(33) 2445 2446var Component = __webpack_require__(3)( 2447 /* script */ 2448 __webpack_require__(6), 2449 /* template */ 2450 __webpack_require__(30), 2451 /* scopeId */ 2452 null, 2453 /* cssModules */ 2454 null 2455) 2456Component.options.__file = "/Users/dcemagine/Documents/Web/living-history/src/js/vue-components/Maps.vue" 2457if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key !== "__esMo
2457dule"})) {console.error("named exports are not supported in *.vue files.")} 2458if (Component.options.functional) {console.error("[vue-loader] Maps.vue: functional components are not supported with templates, they should use render functions.")} 2459 2460/* hot reload */ 2461if (false) {(function () { 2462 var hotAPI = require("vue-hot-reload-api") 2463 hotAPI.install(require("vue"), false) 2464 if (!hotAPI.compatible) return 2465 module.hot.accept() 2466 if (!module.hot.data) { 2467 hotAPI.createRecord("data-v-5c5dc322", Component.options) 2468 } else { 2469 hotAPI.reload("data-v-5c5dc322", Component.options) 2470 } 2471})()} 2472 2473module.exports = Component.exports 2474 2475 2476/***/ }), 2477/* 29 */ 2478/***/ (function(module, exports, __webpack_require__) { 2479 2480var Component = __webpack_require__(3)( 2481 /* script */ 2482 __webpack_require__(7), 2483 /* template */ 2484 __webpack_require__(31), 2485 /* scopeId */ 2486 null, 2487 /* cssModules */ 2488 null 2489) 2490Component.options.__file = "/Users/dcemagine/Documents/Web/living-history/src/js/vue-components/vue-partials/MapCard.vue" 2491if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key !== "__esModule"})) {console.error("named exports are not supported in *.vue files.")} 2492if (Component.options.functional) {console.error("[vue-loader] MapCard.vue: functional components are not supported with templates, they should use render functions.")} 2493 2494/* hot reload */ 2495if (false) {(function () { 2496 var hotAPI = require("vue-hot-reload-api") 2497 hotAPI.install(require("vue"), false) 2498 if (!hotAPI.compatible) return 2499 module.hot.accept() 2500 if (!module.hot.data) { 2501 hotAPI.createRecord("data-v-7039f3e4", Component.options) 2502 } else { 2503 hotAPI.reload("data-v-7039f3e4", Component.options) 2504 } 2505})()} 2506 2507module.exports = Component.exports 2508 2509 2510/***/ }), 2511/* 30 */ 2512/***/ (function(module, exports, __webpack_require__) { 2513 2514module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h; 2515 return _c('div', { 2516 staticClass: "c-maps-component-container" 2517 }, [_c('div', { 2518 staticClass: "banner-section__alternate category map-fixes-wrapper u-pb-10@small-up" 2519 }, [_c('div', { 2520 staticClass: "row" 2521 }, [_vm._m(0, false, false), _vm._v(" "), _c('div', { 2522 staticClass: "text-center" 2523 }, [_c('ul', { 2524 staticClass: "vertical menu c-cat-dropdown", 2525 staticStyle: { 2526 "max-width": "250px" 2527 }, 2528 attrs: { 2529 "data-responsive-menu": "vertical menu medium-accordion", 2530 "accordion-menu": "", 2531 "data-accordion-menu": "" 2532 } 2533 }, [_c('li', { 2534 staticClass: "map-filter-accordion-parent" 2535 }, [_c('a', { 2536 staticClass: "c-cat-dropdown__header", 2537 attrs: { 2538 "href": "#" 2539 } 2540 }, [(_vm.selectedProvince == 'connacht') ? _c('span', [_vm._v("Connaught")]) : (_vm.selectedProvince != 'all') ? _c('span', [_vm._v(_vm._s(_vm.selectedProvince))]) : _c('span', [_vm._v("Filter By Provence")])]), _vm._v(" "), _c('ul', { 2541 staticClass: "vertical menu c-cat-dropdown__item", 2542 attrs: { 2543 "id": "cardFilters" 2544 } 2545 }, [_c('li', [_c('span', { 2546 staticClass: "dropdownBracket" 2547 }, [_c('button', { 2548 staticClass: "map-filter-btn", 2549 on: { 2550 "click": function($event) { 2551 _vm.setSelectedProvince('leinster') 2552 } 2553 } 2554 }, [_c('span', [_vm._v("Leinster")])])])]), _vm._v(" "), _c('li', [_c('span', { 2555 staticClass: "dropdownBracket" 2556 }, [_c('button', { 2557 staticClass: "map-filter-btn", 2558 on: { 2559 "click": function($event) { 2560 _vm.setSelectedProvince('munster') 2561 } 2562 } 2563 }, [_c('span', [_vm._v("Munster")])])])]), _vm._v(" "), _c('li', [_c('span', { 2564 staticClass: "dropdownBracket" 2565 }, [_c('button', { 2566 staticClass: "map-filter-btn", 2567 on: { 2568 "click": function($event) { 2569 _vm.setSelectedProvince('connacht') 2570 } 2571 } 2572 }, [_c('span', [_vm._v("Connaught")])])])]), _vm._v(" "), _c('li', [_c('span', { 2573 staticClass: "dropdownBracket" 2574 }, [_c('button', { 2575 staticClass: "map-filter-btn", 2576 on: { 2577 "click": function($event) { 2578 _vm.setSelectedProvince('ulster') 2579 } 2580 } 2581 }, [_c('span', [_vm._v("Ulster")])])])])])])])])])]), _vm._v(" "), _c('section', { 2582 staticClass: "c-content-block" 2583 }, [(_vm.filteredList.length) ? _c('paginate', { 2584 ref: "paginator", 2585 staticClass: "row small-up-1 medium-up-2 large-up-3 c-card-grid-categories", 2586 attrs: { 2587 "name": "items", 2588 "list": _vm.filteredList, 2589 "per": _vm.perPage, 2590 "tag": "div", 2591 "data-equalizer": "", 2592 "data-equalize-by-row": "true" 2593 } 2594 }, _vm._l((_vm.paginated('items')), function(mapItem, index) { 2595 return _c('div', { 2596 key: index, 2597 staticClass: "column column-block c-card-container" 2598 }, [_c('map-card', { 2599 attrs: { 2600 "mapData": mapItem 2601 } 2602 })], 1) 2603 })) : _vm._e(), _vm._v(" "), _c('div', { 2604 staticClass: "c-pagination--mapLoad u-txt-c" 2605 }, [(_vm.hasMoreItems) ? _c('button', { 2606 staticClass: "next--card c-button", 2607 on: { 2608 "click": _vm.loadMore 2609 } 2610 }, [_vm._v("\n\t Load More\n\t ")]) : _vm._e()])], 1)]) 2611},staticRenderFns: [function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h; 2612 return _c('div', { 2613 staticClass: "banner-section-text small-12 columns map-header-section" 2614 }, [_c('h1', [_vm._v("Maps")]), _vm._v(" "), _c('p', { 2615 staticClass: "u-mb-16@small-up text-above-dropdown" 2616 }, [_vm._v("Explore the bog commission maps by choosing a province using the dropdown below")])]) 2617}]} 2618module.exports.render._withStripped = true 2619if (false) { 2620 module.hot.accept() 2621 if (module.hot.data) { 2622 require("vue-hot-reload-api").rerender("data-v-5c5dc322", module.exports) 2623 } 2624} 2625 2626/***/ }), 2627/* 31 */ 2628/***/ (function(module, exports, __webpack_require__) { 2629 2630module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h; 2631 return _c('a', { 2632 staticClass: "c-map-link", 2633 attrs: { 2634 "href": _vm.mapLink 2635 } 2636 }, [(_vm.mapData) ? _c('div', { 2637 staticClass: "c-map-story" 2638 }, [_c('div', { 2639 staticClass: "c-map-story__image" 2640 }, [_vm._m(0, false, false), _vm._v(" "), (_vm.imageLink) ? _c('div', { 2641 staticClass: "c-map--imagecontainer", 2642 style: ({ 2643 'background-image': 'url(' + _vm.imageLink + ')' 2644 }) 2645 }) : _vm._e()]), _vm._v(" "), _c('div', { 2646 staticClass: "c-map-story__single-content" 2647 }, [_c('div', { 2648 staticClass: "c-map-story__text-container", 2649 attrs: { 2650 "data-equalizer-watch": "" 2651 } 2652 }, [_c('h2', { 2653 staticClass: "c-map-story__title" 2654 }, [_vm._v(_vm._s(_vm.mapData.title))])])])]) : _vm._e()]) 2655},staticRenderFns: [function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h; 2656 return _c('div', { 2657 staticClass: "c-map-story__expand" 2658 }, [_c('span', { 2659 staticClass: "map-icon" 2660 })]) 2661}]} 2662module.exports.render._withStripped = true 2663if (false) { 2664 module.hot.accept() 2665 if (module.hot.data) { 2666 require("vue-hot-reload-api").rerender("data-v-7039f3e4", module.exports) 2667 } 2668} 2669 2670/***/ }), 2671/* 32 */ 2672/***/ (function(module, exports, __webpack_require__) { 2673 2674/* WEBPACK VAR INJECTION */(function(global) {/** 2675 * vue-paginate v3.5.1 2676 * (c) 2017 Taha Shashtari 2677 * @license MIT 2678 */ 2679(function (global, factory) { 2680 true ? module.exports = factory() : 2681 typeof define === 'function' && define.amd ? define(factory) : 2682 (global.VuePaginate = factory()); 2683}(this, function () { 'use strict'; 2684 2685 var warn = function () {} 2686 var formatComponentName 2687 2688 var hasConsole = typeof console !== 'undefined' 2689 2690 warn = function (msg, vm, type) { 2691 if ( type === void 0 ) type = 'error'; 2692 2693 if (hasConsole) { 2694 console[type]("[vue-paginate]: " + msg + " " + ( 2695 vm ? formatLocation(formatComponentName(vm)) : '' 2696 )) 2697 } 2698 } 2699 2700 formatComponentName = function (vm) { 2701 if (vm.$root === vm) { 2702 return 'root instance' 2703 } 2704 var name = vm._isVue 2705 ? vm.$options.name || vm.$options._componentTag 2706 : vm.name 2707 return ( 2708 (name ? ("component <" + name + ">") : "anonymous component") + 2709 (vm._isVue && vm.$options.__file ? (" at " + (vm.$options.__file)) : '') 2710 ) 2711 } 2712 2713 var formatLocation = function (str) { 2714 if (str === 'anonymous component') { 2715 str += " - use the \"name\" option for better debugging messages." 2716 } 2717 return ("\n(found in " + str + ")") 2718 } 2719 2720 var Paginate = { 2721 name: 'paginate', 2722 props: { 2723 name: { 2724 type: String, 2725 required: true 2726 }, 2727 list: { 2728 type: Array, 2729 required: true 2730 }, 2731 per: { 2732 type: Number, 2733 default: 3, 2734 validator: function validator (value) { 2735 return value > 0 2736 } 2737 }, 2738 tag: { 2739 type: String, 2740 default: 'ul' 2741 } 2742 }, 2743 data: function data () { 2744 return { 2745 initialListSize: this.list.length 2746 } 2747 }, 2748 computed: { 2749 currentPage: { 2750 get: function get () { 2751 if (this.$parent.paginate[this.name]) { 2752 return this.$parent.paginate[this.name].page 2753 } 2754 },
2755 set: function set (page) { 2756 this.$parent.paginate[this.name].page = page 2757 } 2758 }, 2759 pageItemsCount: function pageItemsCount () { 2760 var numOfItems = this.list.length 2761 var first = this.currentPage * this.per + 1 2762 var last = Math.min((this.currentPage * this.per) + this.per, numOfItems) 2763 return (first + "-" + last + " of " + numOfItems) 2764 } 2765 }, 2766 mounted: function mounted () { 2767 if (this.per <= 0) { 2768 warn(("<paginate name=\"" + (this.name) + "\"> 'per' prop can't be 0 or less."), this.$parent) 2769 } 2770 if (!this.$parent.paginate[this.name]) { 2771 warn(("'" + (this.name) + "' is not registered in 'paginate' array."), this.$parent) 2772 return 2773 } 2774 this.paginateList() 2775 }, 2776 watch: { 2777 currentPage: function currentPage () { 2778 this.paginateList() 2779 }, 2780 list: function list () { 2781 if (this.initialListSize !== this.list.length) { 2782 // On list change, refresh the paginated list only if list size has changed 2783 this.currentPage = 0 2784 } 2785 this.paginateList() 2786 }, 2787 per: function per () { 2788 this.currentPage = 0 2789 this.paginateList() 2790 } 2791 }, 2792 methods: { 2793 paginateList: function paginateList () { 2794 var index = this.currentPage * this.per 2795 var paginatedList = this.list.slice(index, index + this.per) 2796 this.$parent.paginate[this.name].list = paginatedList 2797 }, 2798 goToPage: function goToPage (page) { 2799 var maxPage = Math.ceil(this.list.length / this.per) 2800 if (page > maxPage) { 2801 warn(("You cannot go to page " + page + ". The last page is " + maxPage + "."), this.$parent) 2802 return 2803 } 2804 this.currentPage = page - 1 2805 } 2806 }, 2807 render: function render (h) { 2808 return h(this.tag, {}, this.$slots.default) 2809 } 2810 } 2811 2812 /*! 2813 * Vue.js v2.3.3 2814 * (c) 2014-2017 Evan You 2815 * Released under the MIT License. 2816 */ 2817 /* */ 2818 2819 // these helpers produces better vm code in JS engines due to their 2820 // explicitness and function inlining 2821 function isUndef (v) { 2822 return v === undefined || v === null 2823 } 2824 2825 function isDef (v) { 2826 return v !== undefined && v !== null 2827 } 2828 2829 function isTrue (v) { 2830 return v === true 2831 } 2832 2833 function isFalse (v) { 2834 return v === false 2835 } 2836 /** 2837 * Check if value is primitive 2838 */ 2839 function isPrimitive (value) { 2840 return typeof value === 'string' || typeof value === 'number' 2841 } 2842 2843 /** 2844 * Quick object check - this is primarily used to tell 2845 * Objects from primitive values when we know the value 2846 * is a JSON-compliant type. 2847 */ 2848 function isObject (obj) { 2849 return obj !== null && typeof obj === 'object' 2850 } 2851 2852 var _toString = Object.prototype.toString; 2853 2854 /** 2855 * Strict object type check. Only returns true 2856 * for plain JavaScript objects. 2857 */ 2858 function isPlainObject (obj) { 2859 return _toString.call(obj) === '[object Object]' 2860 } 2861 2862 function isRegExp (v) { 2863 return _toString.call(v) === '[object RegExp]' 2864 } 2865 2866 /** 2867 * Convert a value to a string that is actually rendered. 2868 */ 2869 function toString (val) { 2870 return val == null 2871 ? '' 2872 : typeof val === 'object' 2873 ? JSON.stringify(val, null, 2) 2874 : String(val) 2875 } 2876 2877 /** 2878 * Convert a input value to a number for persistence. 2879 * If the conversion fails, return original string. 2880 */ 2881 function toNumber (val) { 2882 var n = parseFloat(val); 2883 return isNaN(n) ? val : n 2884 } 2885 2886 /** 2887 * Make a map and return a function for checking if a key 2888 * is in that map. 2889 */ 2890 function makeMap ( 2891 str, 2892 expectsLowerCase 2893 ) { 2894 var map = Object.create(null); 2895 var list = str.split(','); 2896 for (var i = 0; i < list.length; i++) { 2897 map[list[i]] = true; 2898 } 2899 return expectsLowerCase 2900 ? function (val) { return map[val.toLowerCase()]; } 2901 : function (val) { return map[val]; } 2902 } 2903 2904 /** 2905 * Check if a tag is a built-in tag. 2906 */ 2907 var isBuiltInTag = makeMap('slot,component', true); 2908 2909 /** 2910 * Remove an item from an array 2911 */ 2912 function remove (arr, item) { 2913 if (arr.length) { 2914 var index = arr.indexOf(item); 2915 if (index > -1) { 2916 return arr.splice(index, 1) 2917 } 2918 } 2919 } 2920 2921 /** 2922 * Check whether the object has the property. 2923 */ 2924 var hasOwnProperty = Object.prototype.hasOwnProperty; 2925 function hasOwn (obj, key) { 2926 return hasOwnProperty.call(obj, key) 2927 } 2928 2929 /** 2930 * Create a cached version of a pure function. 2931 */ 2932 function cached (fn) { 2933 var cache = Object.create(null); 2934 return (function cachedFn (str) { 2935 var hit = cache[str]; 2936 return hit || (cache[str] = fn(str)) 2937 }) 2938 } 2939 2940 /** 2941 * Camelize a hyphen-delimited string. 2942 */ 2943 var camelizeRE = /-(\w)/g; 2944 var camelize = cached(function (str) { 2945 return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; }) 2946 }); 2947 2948 /** 2949 * Capitalize a string. 2950 */ 2951 var capitalize = cached(function (str) { 2952 return str.charAt(0).toUpperCase() + str.slice(1) 2953 }); 2954 2955 /** 2956 * Hyphenate a camelCase string. 2957 */ 2958 var hyphenateRE = /([^-])([A-Z])/g; 2959 var hyphenate = cached(function (str) { 2960 return str 2961 .replace(hyphenateRE, '$1-$2') 2962 .replace(hyphenateRE, '$1-$2') 2963 .toLowerCase() 2964 }); 2965 2966 /** 2967 * Simple bind, faster than native 2968 */ 2969 function bind (fn, ctx) { 2970 function boundFn (a) { 2971 var l = arguments.length; 2972 return l 2973 ? l > 1 2974 ? fn.apply(ctx, arguments) 2975 : fn.call(ctx, a) 2976 : fn.call(ctx) 2977 } 2978 // record original fn length 2979 boundFn._length = fn.length; 2980 return boundFn 2981 } 2982 2983 /** 2984 * Convert an Array-like object to a real Array. 2985 */ 2986 function toArray (list, start) { 2987 start = start || 0; 2988 var i = list.length - start; 2989 var ret = new Array(i); 2990 while (i--) { 2991 ret[i] = list[i + start]; 2992 } 2993 return ret 2994 } 2995 2996 /** 2997 * Mix properties into target object. 2998 */ 2999 function extend (to, _from) { 3000 for (var key in _from) { 3001 to[key] = _from[key]; 3002 } 3003 return to 3004 } 3005 3006 /** 3007 * Merge an Array of Objects into a single Object. 3008 */ 3009 function toObject (arr) { 3010 var res = {}; 3011 for (var i = 0; i < arr.length; i++) { 3012 if (arr[i]) { 3013 extend(res, arr[i]); 3014 } 3015 } 3016 return res 3017 } 3018 3019 /** 3020 * Perform no operation. 3021 */ 3022 function noop () {} 3023 3024 /** 3025 * Always return false. 3026 */ 3027 var no = function () { return false; }; 3028 3029 /** 3030 * Return same value 3031 */ 3032 var identity = function (_) { return _; }; 3033 3034 /** 3035 * Generate a static keys string from compiler modules. 3036 */ 3037 3038 3039 /** 3040 * Check if two values are loosely equal - that is, 3041 * if they are plain objects, do they have the same shape? 3042 */ 3043 function looseEqual (a, b) { 3044 var isObjectA = isObject(a); 3045 var isObjectB = isObject(b); 3046 if (isObjectA && isObjectB) {
vendor: 63,459 bytes, lines 3047-5503
3047 try { 3048 return JSON.stringify(a) === JSON.stringify(b) 3049 } catch (e) { 3050 // possible circular reference 3051 return a === b 3052 } 3053 } else if (!isObjectA && !isObjectB) { 3054 return String(a) === String(b) 3055 } else { 3056 return false 3057 } 3058 } 3059 3060 function looseIndexOf (arr, val) { 3061 for (var i = 0; i < arr.length; i++) { 3062 if (looseEqual(arr[i], val)) { return i } 3063 } 3064 return -1 3065 } 3066 3067 /** 3068 * Ensure a function is called only once. 3069 */ 3070 function once (fn) { 3071 var called = false; 3072 return function () { 3073 if (!called) { 3074 called = true; 3075 fn.apply(this, arguments); 3076 } 3077 } 3078 } 3079 3080 var SSR_ATTR = 'data-server-rendered'; 3081 3082 var ASSET_TYPES = [ 3083 'component', 3084 'directive', 3085 'filter' 3086 ]; 3087 3088 var LIFECYCLE_HOOKS = [ 3089 'beforeCreate', 3090 'created', 3091 'beforeMount', 3092 'mounted', 3093 'beforeUpdate', 3094 'updated', 3095 'beforeDestroy', 3096 'destroyed', 3097 'activated', 3098 'deactivated' 3099 ]; 3100 3101 /* */ 3102 3103 var config = ({ 3104 /** 3105 * Option merge strategies (used in core/util/options) 3106 */ 3107 optionMergeStrategies: Object.create(null), 3108 3109 /** 3110 * Whether to suppress warnings. 3111 */ 3112 silent: false, 3113 3114 /** 3115 * Show production mode tip message on boot? 3116 */ 3117 productionTip: "production" !== 'production', 3118 3119 /** 3120 * Whether to enable devtools 3121 */ 3122 devtools: "production" !== 'production', 3123 3124 /** 3125 * Whether to record perf 3126 */ 3127 performance: false, 3128 3129 /** 3130 * Error handler for watcher errors 3131 */ 3132 errorHandler: null, 3133 3134 /** 3135 * Ignore certain custom elements 3136 */ 3137 ignoredElements: [], 3138 3139 /** 3140 * Custom user key aliases for v-on 3141 */ 3142 keyCodes: Object.create(null), 3143 3144 /** 3145 * Check if a tag is reserved so that it cannot be registered as a 3146 * component. This is platform-dependent and may be overwritten. 3147 */ 3148 isReservedTag: no, 3149 3150 /** 3151 * Check if an attribute is reserved so that it cannot be used as a component 3152 * prop. This is platform-dependent and may be overwritten. 3153 */ 3154 isReservedAttr: no, 3155 3156 /** 3157 * Check if a tag is an unknown element. 3158 * Platform-dependent. 3159 */ 3160 isUnknownElement: no, 3161 3162 /** 3163 * Get the namespace of an element 3164 */ 3165 getTagNamespace: noop, 3166 3167 /** 3168 * Parse the real tag name for the specific platform. 3169 */ 3170 parsePlatformTagName: identity, 3171 3172 /** 3173 * Check if an attribute must be bound using property, e.g. value 3174 * Platform-dependent. 3175 */ 3176 mustUseProp: no, 3177 3178 /** 3179 * Exposed for legacy reasons 3180 */ 3181 _lifecycleHooks: LIFECYCLE_HOOKS 3182 }); 3183 3184 /* */ 3185 3186 var emptyObject = Object.freeze({}); 3187 3188 /** 3189 * Check if a string starts with $ or _ 3190 */ 3191 function isReserved (str) { 3192 var c = (str + '').charCodeAt(0); 3193 return c === 0x24 || c === 0x5F 3194 } 3195 3196 /** 3197 * Define a property. 3198 */ 3199 function def (obj, key, val, enumerable) { 3200 Object.defineProperty(obj, key, { 3201 value: val, 3202 enumerable: !!enumerable, 3203 writable: true, 3204 configurable: true 3205 }); 3206 } 3207 3208 /** 3209 * Parse simple path. 3210 */ 3211 var bailRE = /[^\w.$]/; 3212 function parsePath (path) { 3213 if (bailRE.test(path)) { 3214 return 3215 } 3216 var segments = path.split('.'); 3217 return function (obj) { 3218 for (var i = 0; i < segments.length; i++) { 3219 if (!obj) { return } 3220 obj = obj[segments[i]]; 3221 } 3222 return obj 3223 } 3224 } 3225 3226 /* */ 3227 3228 var warn$1 = noop; 3229 var tip = noop; 3230 /* */ 3231 3232 function handleError (err, vm, info) { 3233 if (config.errorHandler) { 3234 config.errorHandler.call(null, err, vm, info); 3235 } else { 3236 if (false) {} 3237 /* istanbul ignore else */ 3238 if (inBrowser && typeof console !== 'undefined') { 3239 console.error(err); 3240 } else { 3241 throw err 3242 } 3243 } 3244 } 3245 3246 /* */ 3247 /* globals MutationObserver */ 3248 3249 // can we use __proto__? 3250 var hasProto = '__proto__' in {}; 3251 3252 // Browser environment sniffing 3253 var inBrowser = typeof window !== 'undefined'; 3254 var UA = inBrowser && window.navigator.userAgent.toLowerCase(); 3255 var isIE = UA && /msie|trident/.test(UA); 3256 var isIE9 = UA && UA.indexOf('msie 9.0') > 0; 3257 var isEdge = UA && UA.indexOf('edge/') > 0; 3258 var isAndroid = UA && UA.indexOf('android') > 0; 3259 var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); 3260 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; 3261 3262 var supportsPassive = false; 3263 if (inBrowser) { 3264 try { 3265 var opts = {}; 3266 Object.defineProperty(opts, 'passive', ({ 3267 get: function get () { 3268 /* istanbul ignore next */ 3269 supportsPassive = true; 3270 } 3271 } )); // https://github.com/facebook/flow/issues/285 3272 window.addEventListener('test-passive', null, opts); 3273 } catch (e) {} 3274 } 3275 3276 // this needs to be lazy-evaled because vue may be required before 3277 // vue-server-renderer can set VUE_ENV 3278 var _isServer; 3279 var isServerRendering = function () { 3280 if (_isServer === undefined) { 3281 /* istanbul ignore if */ 3282 if (!inBrowser && typeof global !== 'undefined') { 3283 // detect presence of vue-server-renderer and avoid 3284 // Webpack shimming the process 3285 _isServer = global['process'].env.VUE_ENV === 'server'; 3286 } else { 3287 _isServer = false; 3288 } 3289 } 3290 return _isServer 3291 }; 3292 3293 // detect devtools 3294 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; 3295 3296 /* istanbul ignore next */ 3297 function isNative (Ctor) { 3298 return typeof Ctor === 'function' && /native code/.test(Ctor.toString()) 3299 } 3300 3301 var hasSymbol = 3302 typeof Symbol !== 'undefined' && isNative(Symbol) && 3303 typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); 3304 3305 /** 3306 * Defer a task to execute it asynchronously. 3307 */ 3308 var nextTick = (function () { 3309 var callbacks = []; 3310 var pending = false; 3311 var timerFunc; 3312 3313 function nextTickHandler () { 3314 pending = false; 3315 var copies = callbacks.slice(0); 3316 callbacks.length = 0; 3317 for (var i = 0; i < copies.length; i++) { 3318 copies[i](); 3319 } 3320 } 3321 3322 // the nextTick behavior leverages the microtask queue, which can be accessed 3323 // via either native Promise.then or MutationObserver. 3324 // MutationObserver has wider support, however it is seriously bugged in 3325 // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It 3326 // completely stops working after triggering a few times... so, if native 3327 // Promise is available, we will use it: 3328 /* istanbul ignore if */ 3329 if (typeof Promise !== 'undefined' && isNative(Promise)) { 3330 var p = Promise.resolve(); 3331 var logError = function (err) { console.error(err); }; 3332 timerFunc = function () { 3333 p.then(nextTickHandler).catch(logError); 3334 // in problematic UIWebViews, Promise.then doesn't completely break, but 3335 // it can get stuck in a weird state where callbacks are pushed into the 3336 // microtask queue but the queue isn't being flushed, until the browser 3337 // needs to do some other work, e.g. handle a timer. Therefore we can 3338 // "force" the microtask queue to be flushed by adding an empty timer. 3339 if (isIOS) { setTimeout(noop); } 3340 }; 3341 } else if (typeof MutationObserver !== 'undefined' && ( 3342 isNative(MutationObserver) || 3343 // PhantomJS and iOS 7.x 3344 MutationObserver.toString() === '[object MutationObserverConstructor]' 3345 )) { 3346 // use MutationObserver where native Promise is not available, 3347 // e.g. PhantomJS IE11, iOS7, Android 4.4 3348 var counter = 1; 3349 var observer = new MutationObserver(nextTickHandler); 3350 var textNode = document.createTextNode(String(counter)); 3351 observer.observe(textNode, { 3352 characterData: true 3353 }); 3354 timerFunc = function () { 3355 counter = (counter + 1) % 2; 3356 textNode.data = String(counter); 3357 }; 3358 } else { 3359 // fallback to setTimeout 3360 /* istanbul ignore next */ 3361 timerFunc = function () { 3362 setTimeout(nextTickHandler, 0); 3363 }; 3364 } 3365 3366 return function queueNextTick (cb, ctx) { 3367 var _resolve; 3368 callbacks.push(function () { 3369 if (cb) { 3370 try { 3371 cb.call(ctx); 3372 } catch (e) { 3373 handleError(e, ctx, 'nextTick'); 3374 } 3375 } else if (_resolve) { 3376 _resolve(ctx); 3377 } 3378 }); 3379 if (!pending) { 3380 pending = true; 3381 timerFunc(); 3382 } 3383 if (!cb && typeof Promise !== 'undefined') { 3384 return new Promise(function (resolve, reject) { 3385 _resolve = resolve; 3386 }) 3387 } 3388 } 3389 })(); 3390 3391 var _Set; 3392 /* istanbul ignore if */ 3393 if (typeof Set !== 'undefined' && isNative(Set)) { 3394 // use native Set when available. 3395 _Set = Set; 3396 } else { 3397 // a non-standard Set polyfill that only works with primitive keys. 3398 _Set = (function () { 3399 function Set () { 3400 this.set = Object.create(null); 3401 } 3402 Set.prototype.has = function has (key) { 3403 return this.set[key] === true 3404 }; 3405 Set.prototype.add = function add (key) { 3406 this.set[key] = true; 3407 }; 3408 Set.prototype.clear = function clear () { 3409 this.set = Object.create(null); 3410 }; 3411 3412 return Set; 3413 }()); 3414 } 3415 3416 /* */ 3417 3418 3419 var uid$1 = 0; 3420 3421 /** 3422 * A dep is an observable that can have multiple 3423 * directives subscribing to it. 3424 */ 3425 var Dep = function Dep () { 3426 this.id = uid$1++; 3427 this.subs = []; 3428 }; 3429 3430 Dep.prototype.addSub = function addSub (sub) { 3431 this.subs.push(sub); 3432 }; 3433 3434 Dep.prototype.removeSub = function removeSub (sub) { 3435 remove(this.subs, sub); 3436 }; 3437 3438 Dep.prototype.depend = function depend () { 3439 if (Dep.target) { 3440 Dep.target.addDep(this); 3441 } 3442 }; 3443 3444 Dep.prototype.notify = function notify () { 3445 // stabilize the subscriber list first 3446 var subs = this.subs.slice(); 3447 for (var i = 0, l = subs.length; i < l; i++) { 3448 subs[i].update(); 3449 } 3450 }; 3451 3452 // the current target watcher being evaluated. 3453 // this is globally unique because there could be only one 3454 // watcher being evaluated at any time. 3455 Dep.target = null; 3456 var targetStack = []; 3457 3458 function pushTarget (_target) { 3459 if (Dep.target) { targetStack.push(Dep.target); } 3460 Dep.target = _target; 3461 } 3462 3463 function popTarget () { 3464 Dep.target = targetStack.pop(); 3465 } 3466 3467 /* 3468 * not type checking this file because flow doesn't play well with 3469 * dynamically accessing methods on Array prototype 3470 */ 3471 3472 var arrayProto = Array.prototype; 3473 var arrayMethods = Object.create(arrayProto);[ 3474 'push', 3475 'pop', 3476 'shift', 3477 'unshift', 3478 'splice', 3479 'sort', 3480 'reverse' 3481 ] 3482 .forEach(function (method) { 3483 // cache original method 3484 var original = arrayProto[method]; 3485 def(arrayMethods, method, function mutator () { 3486 var arguments$1 = arguments; 3487 3488 // avoid leaking arguments: 3489 // http://jsperf.com/closure-with-arguments 3490 var i = arguments.length; 3491 var args = new Array(i); 3492 while (i--) { 3493 args[i] = arguments$1[i]; 3494 } 3495 var result = original.apply(this, args); 3496 var ob = this.__ob__; 3497 var inserted; 3498 switch (method) { 3499 case 'push': 3500 inserted = args; 3501 break 3502 case 'unshift': 3503 inserted = args; 3504 break 3505 case 'splice': 3506 inserted = args.slice(2); 3507 break 3508 } 3509 if (inserted) { ob.observeArray(inserted); } 3510 // notify change 3511 ob.dep.notify(); 3512 return result 3513 }); 3514 }); 3515 3516 /* */ 3517 3518 var arrayKeys = Object.getOwnPropertyNames(arrayMethods); 3519 3520 /** 3521 * By default, when a reactive property is set, the new value is 3522 * also converted to become reactive. However when passing down props, 3523 * we don't want to force conversion because the value may be a nested value 3524 * under a frozen data structure. Converting it would defeat the optimization. 3525 */ 3526 var observerState = { 3527 shouldConvert: true, 3528 isSettingProps: false 3529 }; 3530 3531 /** 3532 * Observer class that are attached to each observed 3533 * object. Once attached, the observer converts target 3534 * object's property keys into getter/setters that 3535 * collect dependencies and dispatches updates. 3536 */ 3537 var Observer = function Observer (value) { 3538 this.value = value; 3539 this.dep = new Dep(); 3540 this.vmCount = 0; 3541 def(value, '__ob__', this); 3542 if (Array.isArray(value)) { 3543 var augment = hasProto 3544 ? protoAugment 3545 : copyAugment; 3546 augment(value, arrayMethods, arrayKeys); 3547 this.observeArray(value); 3548 } else { 3549 this.walk(value); 3550 } 3551 }; 3552 3553 /** 3554 * Walk through each property and convert them into 3555 * getter/setters. This method should only be called when 3556 * value type is Object. 3557 */ 3558 Observer.prototype.walk = function walk (obj) { 3559 var keys = Object.keys(obj); 3560 for (var i = 0; i < keys.length; i++) { 3561 defineReactive$$1(obj, keys[i], obj[keys[i]]); 3562 } 3563 }; 3564 3565 /** 3566 * Observe a list of Array items. 3567 */ 3568 Observer.prototype.observeArray = function observeArray (items) { 3569 for (var i = 0, l = items.length; i < l; i++) { 3570 observe(items[i]); 3571 } 3572 }; 3573 3574 // helpers 3575 3576 /** 3577 * Augment an target Object or Array by intercepting 3578 * the prototype chain using __proto__ 3579 */ 3580 function protoAugment (target, src) { 3581 /* eslint-disable no-proto */ 3582 target.__proto__ = src; 3583 /* eslint-enable no-proto */ 3584 } 3585 3586 /** 3587 * Augment an target Object or Array by defining 3588 * hidden properties. 3589 */ 3590 /* istanbul ignore next */ 3591 function copyAugment (target, src, keys) { 3592 for (var i = 0, l = keys.length; i < l; i++) { 3593 var key = keys[i]; 3594 def(target, key, src[key]); 3595 } 3596 } 3597 3598 /** 3599 * Attempt to create an observer instance for a value, 3600 * returns the new observer if successfully observed, 3601 * or the existing observer if the value already has one. 3602 */ 3603 function observe (value, asRootData) { 3604 if (!isObject(value)) { 3605 return 3606 } 3607 var ob; 3608 if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { 3609 ob = value.__ob__; 3610 } else if ( 3611 observerState.shouldConvert && 3612 !isServerRendering() && 3613 (Array.isArray(value) || isPlainObject(value)) && 3614 Object.isExtensible(value) && 3615 !value._isVue 3616 ) { 3617 ob = new Observer(value); 3618 } 3619 if (asRootData && ob) { 3620 ob.vmCount++; 3621 } 3622 return ob 3623 } 3624 3625 /** 3626 * Define a reactive property on an Object. 3627 */ 3628 function defineReactive$$1 ( 3629 obj, 3630 key, 3631 val, 3632 customSetter 3633 ) { 3634 var dep = new Dep(); 3635 3636 var property = Object.getOwnPropertyDescriptor(obj, key); 3637 if (property && property.configurable === false) { 3638 return 3639 } 3640 3641 // cater for pre-defined getter/setters 3642 var getter = property && property.get; 3643 var setter = property && property.set; 3644 3645 var childOb = observe(val); 3646 Object.defineProperty(obj, key, { 3647 enumerable: true, 3648 configurable: true, 3649 get: function reactiveGetter () { 3650 var value = getter ? getter.call(obj) : val; 3651 if (Dep.target) { 3652 dep.depend(); 3653 if (childOb) { 3654 childOb.dep.depend(); 3655 } 3656 if (Array.isArray(value)) { 3657 dependArray(value); 3658 } 3659 } 3660 return value 3661 }, 3662 set: function reactiveSetter (newVal) { 3663 var value = getter ? getter.call(obj) : val; 3664 /* eslint-disable no-self-compare */ 3665 if (newVal === value || (newVal !== newVal && value !== value)) { 3666 return 3667 } 3668 /* eslint-enable no-self-compare */ 3669 if (false) {} 3670 if (setter) { 3671 setter.call(obj, newVal); 3672 } else { 3673 val = newVal; 3674 } 3675 childOb = observe(newVal); 3676 dep.notify(); 3677 } 3678 }); 3679 } 3680 3681 /** 3682 * Set a property on an object. Adds the new property and 3683 * triggers change notification if the property doesn't 3684 * already exist. 3685 */ 3686 function set (target, key, val) { 3687 if (Array.isArray(target) && typeof key === 'number') { 3688 target.length = Math.max(target.length, key); 3689 target.splice(key, 1, val); 3690 return val 3691 } 3692 if (hasOwn(target, key)) { 3693 target[key] = val; 3694 return val 3695 } 3696 var ob = (target ).__ob__; 3697 if (target._isVue || (ob && ob.vmCount)) { 3698 "production" !== 'production' && warn$1( 3699 'Avoid adding reactive properties to a Vue instance or its root $data ' + 3700 'at runtime - declare it upfront in the data option.' 3701 ); 3702 return val 3703 } 3704 if (!ob) { 3705 target[key] = val; 3706 return val 3707 } 3708 defineReactive$$1(ob.value, key, val); 3709 ob.dep.notify(); 3710 return val 3711 } 3712 3713 /** 3714 * Delete a property and trigger change if necessary. 3715 */ 3716 function del (target, key) { 3717 if (Array.isArray(target) && typeof key === 'number') { 3718 target.splice(key, 1); 3719 return 3720 } 3721 var ob = (target ).__ob__; 3722 if (target._isVue || (ob && ob.vmCount)) { 3723 "production" !== 'production' && warn$1( 3724 'Avoid deleting properties on a Vue instance or its root $data ' + 3725 '- just set it to null.' 3726 ); 3727 return 3728 } 3729 if (!hasOwn(target, key)) { 3730 return 3731 } 3732 delete target[key]; 3733 if (!ob) { 3734 return 3735 } 3736 ob.dep.notify(); 3737 } 3738 3739 /** 3740 * Collect dependencies on array elements when the array is touched, since 3741 * we cannot intercept array element access like property getters. 3742 */ 3743 function dependArray (value) { 3744 for (var e = (void 0), i = 0, l = value.length; i < l; i++) { 3745 e = value[i]; 3746 e && e.__ob__ && e.__ob__.dep.depend(); 3747 if (Array.isArray(e)) { 3748 dependArray(e); 3749 } 3750 } 3751 } 3752 3753 /* */ 3754 3755 /** 3756 * Option overwriting strategies are functions that handle 3757 * how to merge a parent option value and a child option 3758 * value into the final value. 3759 */ 3760 var strats = config.optionMergeStrategies; 3761 3762 /** 3763 * Helper that recursively merges two data objects together. 3764 */ 3765 function mergeData (to, from) { 3766 if (!from) { return to } 3767 var key, toVal, fromVal; 3768 var keys = Object.keys(from); 3769 for (var i = 0; i < keys.length; i++) { 3770 key = keys[i]; 3771 toVal = to[key]; 3772 fromVal = from[key]; 3773 if (!hasOwn(to, key)) { 3774 set(to, key, fromVal); 3775 } else if (isPlainObject(toVal) && isPlainObject(fromVal)) { 3776 mergeData(toVal, fromVal); 3777 } 3778 } 3779 return to 3780 } 3781 3782 /** 3783 * Data 3784 */ 3785 strats.data = function ( 3786 parentVal, 3787 childVal, 3788 vm 3789 ) { 3790 if (!vm) { 3791 // in a Vue.extend merge, both should be functions 3792 if (!childVal) { 3793 return parentVal 3794 } 3795 if (typeof childVal !== 'function') { 3796 "production" !== 'production' && warn$1( 3797 'The "data" option should be a function ' + 3798 'that returns a per-instance value in component ' + 3799 'definitions.', 3800 vm 3801 ); 3802 return parentVal 3803 } 3804 if (!parentVal) { 3805 return childVal 3806 } 3807 // when parentVal & childVal are both present, 3808 // we need to return a function that returns the 3809 // merged result of both functions... no need to 3810 // check if parentVal is a function here because 3811 // it has to be a function to pass previous merges. 3812 return function mergedDataFn () { 3813 return mergeData( 3814 childVal.call(this), 3815 parentVal.call(this) 3816 ) 3817 } 3818 } else if (parentVal || childVal) { 3819 return function mergedInstanceDataFn () { 3820 // instance merge 3821 var instanceData = typeof childVal === 'function' 3822 ? childVal.call(vm) 3823 : childVal; 3824 var defaultData = typeof parentVal === 'function' 3825 ? parentVal.call(vm) 3826 : undefined; 3827 if (instanceData) { 3828 return mergeData(instanceData, defaultData) 3829 } else { 3830 return defaultData 3831 } 3832 } 3833 } 3834 }; 3835 3836 /** 3837 * Hooks and props are merged as arrays. 3838 */ 3839 function mergeHook ( 3840 parentVal, 3841 childVal 3842 ) { 3843 return childVal 3844 ? parentVal 3845 ? parentVal.concat(childVal) 3846 : Array.isArray(childVal) 3847 ? childVal 3848 : [childVal] 3849 : parentVal 3850 } 3851 3852 LIFECYCLE_HOOKS.forEach(function (hook) { 3853 strats[hook] = mergeHook; 3854 }); 3855 3856 /** 3857 * Assets 3858 * 3859 * When a vm is present (instance creation), we need to do 3860 * a three-way merge between constructor options, instance 3861 * options and parent options. 3862 */ 3863 function mergeAssets (parentVal, childVal) { 3864 var res = Object.create(parentVal || null); 3865 return childVal 3866 ? extend(res, childVal) 3867 : res 3868 } 3869 3870 ASSET_TYPES.forEach(function (type) { 3871 strats[type + 's'] = mergeAssets; 3872 }); 3873 3874 /** 3875 * Watchers. 3876 * 3877 * Watchers hashes should not overwrite one 3878 * another, so we merge them as arrays. 3879 */ 3880 strats.watch = function (parentVal, childVal) { 3881 /* istanbul ignore if */ 3882 if (!childVal) { return Object.create(parentVal || null) } 3883 if (!parentVal) { return childVal } 3884 var ret = {}; 3885 extend(ret, parentVal); 3886 for (var key in childVal) { 3887 var parent = ret[key]; 3888 var child = childVal[key]; 3889 if (parent && !Array.isArray(parent)) { 3890 parent = [parent]; 3891 } 3892 ret[key] = parent 3893 ? parent.concat(child) 3894 : [child]; 3895 } 3896 return ret 3897 }; 3898 3899 /** 3900 * Other object hashes. 3901 */ 3902 strats.props = 3903 strats.methods = 3904 strats.computed = function (parentVal, childVal) { 3905 if (!childVal) { return Object.create(parentVal || null) } 3906 if (!parentVal) { return childVal } 3907 var ret = Object.create(null); 3908 extend(ret, parentVal); 3909 extend(ret, childVal); 3910 return ret 3911 }; 3912 3913 /** 3914 * Default strategy. 3915 */ 3916 var defaultStrat = function (parentVal, childVal) { 3917 return childVal === undefined 3918 ? parentVal 3919 : childVal 3920 }; 3921 3922 /** 3923 * Ensure all props option syntax are normalized into the 3924 * Object-based format. 3925 */ 3926 function normalizeProps (options) { 3927 var props = options.props; 3928 if (!props) { return } 3929 var res = {}; 3930 var i, val, name; 3931 if (Array.isArray(props)) { 3932 i = props.length; 3933 while (i--) { 3934 val = props[i]; 3935 if (typeof val === 'string') { 3936 name = camelize(val); 3937 res[name] = { type: null }; 3938 } else if (false) {} 3939 } 3940 } else if (isPlainObject(props)) { 3941 for (var key in props) { 3942 val = props[key]; 3943 name = camelize(key); 3944 res[name] = isPlainObject(val) 3945 ? val 3946 : { type: val }; 3947 } 3948 } 3949 options.props = res; 3950 } 3951 3952 /** 3953 * Normalize raw function directives into object format. 3954 */ 3955 function normalizeDirectives (options) { 3956 var dirs = options.directives; 3957 if (dirs) { 3958 for (var key in dirs) { 3959 var def = dirs[key]; 3960 if (typeof def === 'function') { 3961 dirs[key] = { bind: def, update: def }; 3962 } 3963 } 3964 } 3965 } 3966 3967 /** 3968 * Merge two option objects into a new one. 3969 * Core utility used in both instantiation and inheritance. 3970 */ 3971 function mergeOptions ( 3972 parent, 3973 child, 3974 vm 3975 ) { 3976 if (false) {} 3977 3978 if (typeof child === 'function') { 3979 child = child.options; 3980 } 3981 3982 normalizeProps(child); 3983 normalizeDirectives(child); 3984 var extendsFrom = child.extends; 3985 if (extendsFrom) { 3986 parent = mergeOptions(parent, extendsFrom, vm); 3987 } 3988 if (child.mixins) { 3989 for (var i = 0, l = child.mixins.length; i < l; i++) { 3990 parent = mergeOptions(parent, child.mixins[i], vm); 3991 } 3992 } 3993 var options = {}; 3994 var key; 3995 for (key in parent) { 3996 mergeField(key); 3997 } 3998 for (key in child) { 3999 if (!hasOwn(parent, key)) { 4000 mergeField(key); 4001 } 4002 } 4003 function mergeField (key) { 4004 var strat = strats[key] || defaultStrat; 4005 options[key] = strat(parent[key], child[key], vm, key); 4006 } 4007 return options 4008 } 4009 4010 /** 4011 * Resolve an asset. 4012 * This function is used because child instances need access 4013 * to assets defined in its ancestor chain. 4014 */ 4015 function resolveAsset ( 4016 options, 4017 type, 4018 id, 4019 warnMissing 4020 ) { 4021 /* istanbul ignore if */ 4022 if (typeof id !== 'string') { 4023 return 4024 } 4025 var assets = options[type]; 4026 // check local registration variations first 4027 if (hasOwn(assets, id)) { return assets[id] } 4028 var camelizedId = camelize(id); 4029 if (hasOwn(assets, camelizedId)) { return assets[camelizedId] } 4030 var PascalCaseId = capitalize(camelizedId); 4031 if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] } 4032 // fallback to prototype chain 4033 var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; 4034 if (false) {} 4035 return res 4036 } 4037 4038 /* */ 4039 4040 function validateProp ( 4041 key, 4042 propOptions, 4043 propsData, 4044 vm 4045 ) { 4046 var prop = propOptions[key]; 4047 var absent = !hasOwn(propsData, key); 4048 var value = propsData[key]; 4049 // handle boolean props 4050 if (isType(Boolean, prop.type)) { 4051 if (absent && !hasOwn(prop, 'default')) { 4052 value = false; 4053 } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) { 4054 value = true; 4055 } 4056 } 4057 // check default value 4058 if (value === undefined) { 4059 value = getPropDefaultValue(vm, prop, key); 4060 // since the default value is a fresh copy, 4061 // make sure to observe it. 4062 var prevShouldConvert = observerState.shouldConvert; 4063 observerState.shouldConvert = true; 4064 observe(value); 4065 observerState.shouldConvert = prevShouldConvert; 4066 } 4067 if (false) {} 4068 return value 4069 } 4070 4071 /** 4072 * Get the default value of a prop. 4073 */ 4074 function getPropDefaultValue (vm, prop, key) { 4075 // no default, return undefined 4076 if (!hasOwn(prop, 'default')) { 4077 return undefined 4078 } 4079 var def = prop.default; 4080 // warn against non-factory defaults for Object & Array 4081 if (false) {} 4082 // the raw prop value was also undefined from previous render, 4083 // return previous default value to avoid unnecessary watcher trigger 4084 if (vm && vm.$options.propsData && 4085 vm.$options.propsData[key] === undefined && 4086 vm._props[key] !== undefined 4087 ) { 4088 return vm._props[key] 4089 } 4090 // call factory function for non-Function types 4091 // a value is Function if its prototype is function even across different execution context 4092 return typeof def === 'function' && getType(prop.type) !== 'Function' 4093 ? def.call(vm) 4094 : def 4095 } 4096 4097 /** 4098 * Use function string name to check built-in types, 4099 * because a simple equality check will fail when running 4100 * across different vms / iframes. 4101 */ 4102 function getType (fn) { 4103 var match = fn && fn.toString().match(/^\s*function (\w+)/); 4104 return match ? match[1] : '' 4105 } 4106 4107 function isType (type, fn) { 4108 if (!Array.isArray(fn)) { 4109 return getType(fn) === getType(type) 4110 } 4111 for (var i = 0, len = fn.length; i < len; i++) { 4112 if (getType(fn[i]) === getType(type)) { 4113 return true 4114 } 4115 } 4116 /* istanbul ignore next */ 4117 return false 4118 } 4119 4120 var mark; 4121 /* */ 4122 4123 var VNode = function VNode ( 4124 tag, 4125 data, 4126 children, 4127 text, 4128 elm, 4129 context, 4130 componentOptions 4131 ) { 4132 this.tag = tag; 4133 this.data = data; 4134 this.children = children; 4135 this.text = text; 4136 this.elm = elm; 4137 this.ns = undefined; 4138 this.context = context; 4139 this.functionalContext = undefined; 4140 this.key = data && data.key; 4141 this.componentOptions = componentOptions; 4142 this.componentInstance = undefined; 4143 this.parent = undefined; 4144 this.raw = false; 4145 this.isStatic = false; 4146 this.isRootInsert = true; 4147 this.isComment = false; 4148 this.isCloned = false; 4149 this.isOnce = false; 4150 }; 4151 4152 var prototypeAccessors = { child: {} }; 4153 4154 // DEPRECATED: alias for componentInstance for backwards compat. 4155 /* istanbul ignore next */ 4156 prototypeAccessors.child.get = function () { 4157 return this.componentInstance 4158 }; 4159 4160 Object.defineProperties( VNode.prototype, prototypeAccessors ); 4161 4162 var createEmptyVNode = function () { 4163 var node = new VNode(); 4164 node.text = ''; 4165 node.isComment = true; 4166 return node 4167 }; 4168 4169 function createTextVNode (val) { 4170 return new VNode(undefined, undefined, undefined, String(val)) 4171 } 4172 4173 // optimized shallow clone 4174 // used for static nodes and slot nodes because they may be reused across 4175 // multiple renders, cloning them avoids errors when DOM manipulations rely 4176 // on their elm reference. 4177 function cloneVNode (vnode) { 4178 var cloned = new VNode( 4179 vnode.tag, 4180 vnode.data, 4181 vnode.children, 4182 vnode.text, 4183 vnode.elm, 4184 vnode.context, 4185 vnode.componentOptions 4186 ); 4187 cloned.ns = vnode.ns; 4188 cloned.isStatic = vnode.isStatic; 4189 cloned.key = vnode.key; 4190 cloned.isComment = vnode.isComment; 4191 cloned.isCloned = true; 4192 return cloned 4193 } 4194 4195 function cloneVNodes (vnodes) { 4196 var len = vnodes.length; 4197 var res = new Array(len); 4198 for (var i = 0; i < len; i++) { 4199 res[i] = cloneVNode(vnodes[i]); 4200 } 4201 return res 4202 } 4203 4204 /* */ 4205 4206 var normalizeEvent = cached(function (name) { 4207 var passive = name.charAt(0) === '&'; 4208 name = passive ? name.slice(1) : name; 4209 var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first 4210 name = once$$1 ? name.slice(1) : name; 4211 var capture = name.charAt(0) === '!'; 4212 name = capture ? name.slice(1) : name; 4213 return { 4214 name: name, 4215 once: once$$1, 4216 capture: capture, 4217 passive: passive 4218 } 4219 }); 4220 4221 function createFnInvoker (fns) { 4222 function invoker () { 4223 var arguments$1 = arguments; 4224 4225 var fns = invoker.fns; 4226 if (Array.isArray(fns)) { 4227 for (var i = 0; i < fns.length; i++) { 4228 fns[i].apply(null, arguments$1); 4229 } 4230 } else { 4231 // return handler return value for single handlers 4232 return fns.apply(null, arguments) 4233 } 4234 } 4235 invoker.fns = fns; 4236 return invoker 4237 } 4238 4239 function updateListeners ( 4240 on, 4241 oldOn, 4242 add, 4243 remove$$1, 4244 vm 4245 ) { 4246 var name, cur, old, event; 4247 for (name in on) { 4248 cur = on[name]; 4249 old = oldOn[name]; 4250 event = normalizeEvent(name); 4251 if (isUndef(cur)) { 4252 "production" !== 'production' && warn$1( 4253 "Invalid handler for event \"" + (event.name) + "\": got " + String(cur), 4254 vm 4255 ); 4256 } else if (isUndef(old)) { 4257 if (isUndef(cur.fns)) { 4258 cur = on[name] = createFnInvoker(cur); 4259 } 4260 add(event.name, cur, event.once, event.capture, event.passive); 4261 } else if (cur !== old) { 4262 old.fns = cur; 4263 on[name] = old; 4264 } 4265 } 4266 for (name in oldOn) { 4267 if (isUndef(on[name])) { 4268 event = normalizeEvent(name); 4269 remove$$1(event.name, oldOn[name], event.capture); 4270 } 4271 } 4272 } 4273 4274 /* */ 4275 4276 function mergeVNodeHook (def, hookKey, hook) { 4277 var invoker; 4278 var oldHook = def[hookKey]; 4279 4280 function wrappedHook () { 4281 hook.apply(this, arguments); 4282 // important: remove merged hook to ensure it's called only once 4283 // and prevent memory leak 4284 remove(invoker.fns, wrappedHook); 4285 } 4286 4287 if (isUndef(oldHook)) { 4288 // no existing hook 4289 invoker = createFnInvoker([wrappedHook]); 4290 } else { 4291 /* istanbul ignore if */ 4292 if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { 4293 // already a merged invoker 4294 invoker = oldHook; 4295 invoker.fns.push(wrappedHook); 4296 } else { 4297 // existing plain hook 4298 invoker = createFnInvoker([oldHook, wrappedHook]); 4299 } 4300 } 4301 4302 invoker.merged = true; 4303 def[hookKey] = invoker; 4304 } 4305 4306 /* */ 4307 4308 function extractPropsFromVNodeData ( 4309 data, 4310 Ctor, 4311 tag 4312 ) { 4313 // we are only extracting raw values here. 4314 // validation and default values are handled in the child 4315 // component itself. 4316 var propOptions = Ctor.options.props; 4317 if (isUndef(propOptions)) { 4318 return 4319 } 4320 var res = {}; 4321 var attrs = data.attrs; 4322 var props = data.props; 4323 if (isDef(attrs) || isDef(props)) { 4324 for (var key in propOptions) { 4325 var altKey = hyphenate(key); 4326 if (false) {} 4327 checkProp(res, props, key, altKey, true) || 4328 checkProp(res, attrs, key, altKey, false); 4329 } 4330 } 4331 return res 4332 } 4333 4334 function checkProp ( 4335 res, 4336 hash, 4337 key, 4338 altKey, 4339 preserve 4340 ) { 4341 if (isDef(hash)) { 4342 if (hasOwn(hash, key)) { 4343 res[key] = hash[key]; 4344 if (!preserve) { 4345 delete hash[key]; 4346 } 4347 return true 4348 } else if (hasOwn(hash, altKey)) { 4349 res[key] = hash[altKey]; 4350 if (!preserve) { 4351 delete hash[altKey]; 4352 } 4353 return true 4354 } 4355 } 4356 return false 4357 } 4358 4359 /* */ 4360 4361 // The template compiler attempts to minimize the need for normalization by 4362 // statically analyzing the template at compile time. 4363 // 4364 // For plain HTML markup, normalization can be completely skipped because the 4365 // generated render function is guaranteed to return Array<VNode>. There are 4366 // two cases where extra normalization is needed: 4367 4368 // 1. When the children contains components - because a functional component 4369 // may return an Array instead of a single root. In this case, just a simple 4370 // normalization is needed - if any child is an Array, we flatten the whole 4371 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 4372 // because functional components already normalize their own children. 4373 function simpleNormalizeChildren (children) { 4374 for (var i = 0; i < children.length; i++) { 4375 if (Array.isArray(children[i])) { 4376 return Array.prototype.concat.apply([], children) 4377 } 4378 } 4379 return children 4380 } 4381 4382 // 2. When the children contains constructs that always generated nested Arrays, 4383 // e.g. <template>, <slot>, v-for, or when the children is provided by user 4384 // with hand-written render functions / JSX. In such cases a full normalization 4385 // is needed to cater to all possible types of children values. 4386 function normalizeChildren (children) { 4387 return isPrimitive(children) 4388 ? [createTextVNode(children)] 4389 : Array.isArray(children) 4390 ? normalizeArrayChildren(children) 4391 : undefined 4392 } 4393 4394 function isTextNode (node) { 4395 return isDef(node) && isDef(node.text) && isFalse(node.isComment) 4396 } 4397 4398 function normalizeArrayChildren (children, nestedIndex) { 4399 var res = []; 4400 var i, c, last; 4401 for (i = 0; i < children.length; i++) { 4402 c = children[i]; 4403 if (isUndef(c) || typeof c === 'boolean') { continue } 4404 last = res[res.length - 1]; 4405 // nested 4406 if (Array.isArray(c)) { 4407 res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i))); 4408 } else if (isPrimitive(c)) { 4409 if (isTextNode(last)) { 4410 // merge adjacent text nodes 4411 // this is necessary for SSR hydration because text nodes are 4412 // essentially merged when rendered to HTML strings 4413 (last).text += String(c); 4414 } else if (c !== '') { 4415 // convert primitive to vnode 4416 res.push(createTextVNode(c)); 4417 } 4418 } else { 4419 if (isTextNode(c) && isTextNode(last)) { 4420 // merge adjacent text nodes 4421 res[res.length - 1] = createTextVNode(last.text + c.text); 4422 } else { 4423 // default key for nested array children (likely generated by v-for) 4424 if (isTrue(children._isVList) && 4425 isDef(c.tag) && 4426 isUndef(c.key) && 4427 isDef(nestedIndex)) { 4428 c.key = "__vlist" + nestedIndex + "_" + i + "__"; 4429 } 4430 res.push(c); 4431 } 4432 } 4433 } 4434 return res 4435 } 4436 4437 /* */ 4438 4439 function ensureCtor (comp, base) { 4440 return isObject(comp) 4441 ? base.extend(comp) 4442 : comp 4443 } 4444 4445 function resolveAsyncComponent ( 4446 factory, 4447 baseCtor, 4448 context 4449 ) { 4450 if (isTrue(factory.error) && isDef(factory.errorComp)) { 4451 return factory.errorComp 4452 } 4453 4454 if (isDef(factory.resolved)) { 4455 return factory.resolved 4456 } 4457 4458 if (isTrue(factory.loading) && isDef(factory.loadingComp)) { 4459 return factory.loadingComp 4460 } 4461 4462 if (isDef(factory.contexts)) { 4463 // already pending 4464 factory.contexts.push(context); 4465 } else { 4466 var contexts = factory.contexts = [context]; 4467 var sync = true; 4468 4469 var forceRender = function () { 4470 for (var i = 0, l = contexts.length; i < l; i++) { 4471 contexts[i].$forceUpdate(); 4472 } 4473 }; 4474 4475 var resolve = once(function (res) { 4476 // cache resolved 4477 factory.resolved = ensureCtor(res, baseCtor); 4478 // invoke callbacks only if this is not a synchronous resolve 4479 // (async resolves are shimmed as synchronous during SSR) 4480 if (!sync) { 4481 forceRender(); 4482 } 4483 }); 4484 4485 var reject = once(function (reason) { 4486 "production" !== 'production' && warn$1( 4487 "Failed to resolve async component: " + (String(factory)) + 4488 (reason ? ("\nReason: " + reason) : '') 4489 ); 4490 if (isDef(factory.errorComp)) { 4491 factory.error = true; 4492 forceRender(); 4493 } 4494 }); 4495 4496 var res = factory(resolve, reject); 4497 4498 if (isObject(res)) { 4499 if (typeof res.then === 'function') { 4500 // () => Promise 4501 if (isUndef(factory.resolved)) { 4502 res.then(resolve, reject); 4503 } 4504 } else if (isDef(res.component) && typeof res.component.then === 'function') { 4505 res.component.then(resolve, reject); 4506 4507 if (isDef(res.error)) { 4508 factory.errorComp = ensureCtor(res.error, baseCtor); 4509 } 4510 4511 if (isDef(res.loading)) { 4512 factory.loadingComp = ensureCtor(res.loading, baseCtor); 4513 if (res.delay === 0) { 4514 factory.loading = true; 4515 } else { 4516 setTimeout(function () { 4517 if (isUndef(factory.resolved) && isUndef(factory.error)) { 4518 factory.loading = true; 4519 forceRender(); 4520 } 4521 }, res.delay || 200); 4522 } 4523 } 4524 4525 if (isDef(res.timeout)) { 4526 setTimeout(function () { 4527 if (isUndef(factory.resolved)) { 4528 reject( 4529 null 4530 ); 4531 } 4532 }, res.timeout); 4533 } 4534 } 4535 } 4536 4537 sync = false; 4538 // return in case resolved synchronously 4539 return factory.loading 4540 ? factory.loadingComp 4541 : factory.resolved 4542 } 4543 } 4544 4545 /* */ 4546 4547 function getFirstComponentChild (children) { 4548 if (Array.isArray(children)) { 4549 for (var i = 0; i < children.length; i++) { 4550 var c = children[i]; 4551 if (isDef(c) && isDef(c.componentOptions)) { 4552 return c 4553 } 4554 } 4555 } 4556 } 4557 4558 /* */ 4559 4560 /* */ 4561 4562 function initEvents (vm) { 4563 vm._events = Object.create(null); 4564 vm._hasHookEvent = false; 4565 // init parent attached events 4566 var listeners = vm.$options._parentListeners; 4567 if (listeners) { 4568 updateComponentListeners(vm, listeners); 4569 } 4570 } 4571 4572 var target; 4573 4574 function add (event, fn, once$$1) { 4575 if (once$$1) { 4576 target.$once(event, fn); 4577 } else { 4578 target.$on(event, fn); 4579 } 4580 } 4581 4582 function remove$1 (event, fn) { 4583 target.$off(event, fn); 4584 } 4585 4586 function updateComponentListeners ( 4587 vm, 4588 listeners, 4589 oldListeners 4590 ) { 4591 target = vm; 4592 updateListeners(listeners, oldListeners || {}, add, remove$1, vm); 4593 } 4594 4595 function eventsMixin (Vue) { 4596 var hookRE = /^hook:/; 4597 Vue.prototype.$on = function (event, fn) { 4598 var this$1 = this; 4599 4600 var vm = this; 4601 if (Array.isArray(event)) { 4602 for (var i = 0, l = event.length; i < l; i++) { 4603 this$1.$on(event[i], fn); 4604 } 4605 } else { 4606 (vm._events[event] || (vm._events[event] = [])).push(fn); 4607 // optimize hook:event cost by using a boolean flag marked at registration 4608 // instead of a hash lookup 4609 if (hookRE.test(event)) { 4610 vm._hasHookEvent = true; 4611 } 4612 } 4613 return vm 4614 }; 4615 4616 Vue.prototype.$once = function (event, fn) { 4617 var vm = this; 4618 function on () { 4619 vm.$off(event, on); 4620 fn.apply(vm, arguments); 4621 } 4622 on.fn = fn; 4623 vm.$on(event, on); 4624 return vm 4625 }; 4626 4627 Vue.prototype.$off = function (event, fn) { 4628 var this$1 = this; 4629 4630 var vm = this; 4631 // all 4632 if (!arguments.length) { 4633 vm._events = Object.create(null); 4634 return vm 4635 } 4636 // array of events 4637 if (Array.isArray(event)) { 4638 for (var i$1 = 0, l = event.length; i$1 < l; i$1++) { 4639 this$1.$off(event[i$1], fn); 4640 } 4641 return vm 4642 } 4643 // specific event 4644 var cbs = vm._events[event]; 4645 if (!cbs) { 4646 return vm 4647 } 4648 if (arguments.length === 1) { 4649 vm._events[event] = null; 4650 return vm 4651 } 4652 // specific handler 4653 var cb; 4654 var i = cbs.length; 4655 while (i--) { 4656 cb = cbs[i]; 4657 if (cb === fn || cb.fn === fn) { 4658 cbs.splice(i, 1); 4659 break 4660 } 4661 } 4662 return vm 4663 }; 4664 4665 Vue.prototype.$emit = function (event) { 4666 var vm = this; 4667 if (false) {} 4668 var cbs = vm._events[event]; 4669 if (cbs) { 4670 cbs = cbs.length > 1 ? toArray(cbs) : cbs; 4671 var args = toArray(arguments, 1); 4672 for (var i = 0, l = cbs.length; i < l; i++) { 4673 cbs[i].apply(vm, args); 4674 } 4675 } 4676 return vm 4677 }; 4678 } 4679 4680 /* */ 4681 4682 /** 4683 * Runtime helper for resolving raw children VNodes into a slot object. 4684 */ 4685 function resolveSlots ( 4686 children, 4687 context 4688 ) { 4689 var slots = {}; 4690 if (!children) { 4691 return slots 4692 } 4693 var defaultSlot = []; 4694 for (var i = 0, l = children.length; i < l; i++) { 4695 var child = children[i]; 4696 // named slots should only be respected if the vnode was rendered in the 4697 // same context. 4698 if ((child.context === context || child.functionalContext === context) && 4699 child.data && child.data.slot != null 4700 ) { 4701 var name = child.data.slot; 4702 var slot = (slots[name] || (slots[name] = [])); 4703 if (child.tag === 'template') { 4704 slot.push.apply(slot, child.children); 4705 } else { 4706 slot.push(child); 4707 } 4708 } else { 4709 defaultSlot.push(child); 4710 } 4711 } 4712 // ignore whitespace 4713 if (!defaultSlot.every(isWhitespace)) { 4714 slots.default = defaultSlot; 4715 } 4716 return slots 4717 } 4718 4719 function isWhitespace (node) { 4720 return node.isComment || node.text === ' ' 4721 } 4722 4723 function resolveScopedSlots ( 4724 fns, // see flow/vnode 4725 res 4726 ) { 4727 res = res || {}; 4728 for (var i = 0; i < fns.length; i++) { 4729 if (Array.isArray(fns[i])) { 4730 resolveScopedSlots(fns[i], res); 4731 } else { 4732 res[fns[i].key] = fns[i].fn; 4733 } 4734 } 4735 return res 4736 } 4737 4738 /* */ 4739 4740 var activeInstance = null; 4741 4742 function initLifecycle (vm) { 4743 var options = vm.$options; 4744 4745 // locate first non-abstract parent 4746 var parent = options.parent; 4747 if (parent && !options.abstract) { 4748 while (parent.$options.abstract && parent.$parent) { 4749 parent = parent.$parent; 4750 } 4751 parent.$children.push(vm); 4752 } 4753 4754 vm.$parent = parent; 4755 vm.$root = parent ? parent.$root : vm; 4756 4757 vm.$children = []; 4758 vm.$refs = {}; 4759 4760 vm._watcher = null; 4761 vm._inactive = null; 4762 vm._directInactive = false; 4763 vm._isMounted = false; 4764 vm._isDestroyed = false; 4765 vm._isBeingDestroyed = false; 4766 } 4767 4768 function lifecycleMixin (Vue) { 4769 Vue.prototype._update = function (vnode, hydrating) { 4770 var vm = this; 4771 if (vm._isMounted) { 4772 callHook(vm, 'beforeUpdate'); 4773 } 4774 var prevEl = vm.$el; 4775 var prevVnode = vm._vnode; 4776 var prevActiveInstance = activeInstance; 4777 activeInstance = vm; 4778 vm._vnode = vnode; 4779 // Vue.prototype.__patch__ is injected in entry points 4780 // based on the rendering backend used. 4781 if (!prevVnode) { 4782 // initial render 4783 vm.$el = vm.__patch__( 4784 vm.$el, vnode, hydrating, false /* removeOnly */, 4785 vm.$options._parentElm, 4786 vm.$options._refElm 4787 ); 4788 } else { 4789 // updates 4790 vm.$el = vm.__patch__(prevVnode, vnode); 4791 } 4792 activeInstance = prevActiveInstance; 4793 // update __vue__ reference 4794 if (prevEl) { 4795 prevEl.__vue__ = null; 4796 } 4797 if (vm.$el) { 4798 vm.$el.__vue__ = vm; 4799 } 4800 // if parent is an HOC, update its $el as well 4801 if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { 4802 vm.$parent.$el = vm.$el; 4803 } 4804 // updated hook is called by the scheduler to ensure that children are 4805 // updated in a parent's updated hook. 4806 }; 4807 4808 Vue.prototype.$forceUpdate = function () { 4809 var vm = this; 4810 if (vm._watcher) { 4811 vm._watcher.update(); 4812 } 4813 }; 4814 4815 Vue.prototype.$destroy = function () { 4816 var vm = this; 4817 if (vm._isBeingDestroyed) { 4818 return 4819 } 4820 callHook(vm, 'beforeDestroy'); 4821 vm._isBeingDestroyed = true; 4822 // remove self from parent 4823 var parent = vm.$parent; 4824 if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { 4825 remove(parent.$children, vm); 4826 } 4827 // teardown watchers 4828 if (vm._watcher) { 4829 vm._watcher.teardown(); 4830 } 4831 var i = vm._watchers.length; 4832 while (i--) { 4833 vm._watchers[i].teardown(); 4834 } 4835 // remove reference from data ob 4836 // frozen object may not have observer. 4837 if (vm._data.__ob__) { 4838 vm._data.__ob__.vmCount--; 4839 } 4840 // call the last hook... 4841 vm._isDestroyed = true; 4842 // invoke destroy hooks on current rendered tree 4843 vm.__patch__(vm._vnode, null); 4844 // fire destroyed hook 4845 callHook(vm, 'destroyed'); 4846 // turn off all instance listeners. 4847 vm.$off(); 4848 // remove __vue__ reference 4849 if (vm.$el) { 4850 vm.$el.__vue__ = null; 4851 } 4852 // remove reference to DOM nodes (prevents leak) 4853 vm.$options._parentElm = vm.$options._refElm = null; 4854 }; 4855 } 4856 4857 function mountComponent ( 4858 vm, 4859 el, 4860 hydrating 4861 ) { 4862 vm.$el = el; 4863 if (!vm.$options.render) { 4864 vm.$options.render = createEmptyVNode; 4865 if (false) {} 4866 } 4867 callHook(vm, 'beforeMount'); 4868 4869 var updateComponent; 4870 /* istanbul ignore if */ 4871 if (false) {} else { 4872 updateComponent = function () { 4873 vm._update(vm._render(), hydrating); 4874 }; 4875 } 4876 4877 vm._watcher = new Watcher(vm, updateComponent, noop); 4878 hydrating = false; 4879 4880 // manually mounted instance, call mounted on self 4881 // mounted is called for render-created child components in its inserted hook 4882 if (vm.$vnode == null) { 4883 vm._isMounted = true; 4884 callHook(vm, 'mounted'); 4885 } 4886 return vm 4887 } 4888 4889 function updateChildComponent ( 4890 vm, 4891 propsData, 4892 listeners, 4893 parentVnode, 4894 renderChildren 4895 ) { 4896 // determine whether component has slot children 4897 // we need to do this before overwriting $options._renderChildren 4898 var hasChildren = !!( 4899 renderChildren || // has new static slots 4900 vm.$options._renderChildren || // has old static slots 4901 parentVnode.data.scopedSlots || // has new scoped slots 4902 vm.$scopedSlots !== emptyObject // has old scoped slots 4903 ); 4904 4905 vm.$options._parentVnode = parentVnode; 4906 vm.$vnode = parentVnode; // update vm's placeholder node without re-render 4907 if (vm._vnode) { // update child tree's parent 4908 vm._vnode.parent = parentVnode; 4909 } 4910 vm.$options._renderChildren = renderChildren; 4911 4912 // update props 4913 if (propsData && vm.$options.props) { 4914 observerState.shouldConvert = false; 4915 if (false) {} 4916 var props = vm._props; 4917 var propKeys = vm.$options._propKeys || []; 4918 for (var i = 0; i < propKeys.length; i++) { 4919 var key = propKeys[i]; 4920 props[key] = validateProp(key, vm.$options.props, propsData, vm); 4921 } 4922 observerState.shouldConvert = true; 4923 if (false) {} 4924 // keep a copy of raw propsData 4925 vm.$options.propsData = propsData; 4926 } 4927 // update listeners 4928 if (listeners) { 4929 var oldListeners = vm.$options._parentListeners; 4930 vm.$options._parentListeners = listeners; 4931 updateComponentListeners(vm, listeners, oldListeners); 4932 } 4933 // resolve slots + force update if has children 4934 if (hasChildren) { 4935 vm.$slots = resolveSlots(renderChildren, parentVnode.context); 4936 vm.$forceUpdate(); 4937 } 4938 } 4939 4940 function isInInactiveTree (vm) { 4941 while (vm && (vm = vm.$parent)) { 4942 if (vm._inactive) { return true } 4943 } 4944 return false 4945 } 4946 4947 function activateChildComponent (vm, direct) { 4948 if (direct) { 4949 vm._directInactive = false; 4950 if (isInInactiveTree(vm)) { 4951 return 4952 } 4953 } else if (vm._directInactive) { 4954 return 4955 } 4956 if (vm._inactive || vm._inactive === null) { 4957 vm._inactive = false; 4958 for (var i = 0; i < vm.$children.length; i++) { 4959 activateChildComponent(vm.$children[i]); 4960 } 4961 callHook(vm, 'activated'); 4962 } 4963 } 4964 4965 function deactivateChildComponent (vm, direct) { 4966 if (direct) { 4967 vm._directInactive = true; 4968 if (isInInactiveTree(vm)) { 4969 return 4970 } 4971 } 4972 if (!vm._inactive) { 4973 vm._inactive = true; 4974 for (var i = 0; i < vm.$children.length; i++) { 4975 deactivateChildComponent(vm.$children[i]); 4976 } 4977 callHook(vm, 'deactivated'); 4978 } 4979 } 4980 4981 function callHook (vm, hook) { 4982 var handlers = vm.$options[hook]; 4983 if (handlers) { 4984 for (var i = 0, j = handlers.length; i < j; i++) { 4985 try { 4986 handlers[i].call(vm); 4987 } catch (e) { 4988 handleError(e, vm, (hook + " hook")); 4989 } 4990 } 4991 } 4992 if (vm._hasHookEvent) { 4993 vm.$emit('hook:' + hook); 4994 } 4995 } 4996 4997 var queue = []; 4998 var activatedChildren = []; 4999 var has = {}; 5000 var waiting = false; 5001 var flushing = false; 5002 var index = 0; 5003 5004 /** 5005 * Reset the scheduler's state. 5006 */ 5007 function resetSchedulerState () { 5008 index = queue.length = activatedChildren.length = 0; 5009 has = {}; 5010 if (false) {} 5011 waiting = flushing = false; 5012 } 5013 5014 /** 5015 * Flush both queues and run the watchers. 5016 */ 5017 function flushSchedulerQueue () { 5018 flushing = true; 5019 var watcher, id; 5020 5021 // Sort queue before flush. 5022 // This ensures that: 5023 // 1. Components are updated from parent to child. (because parent is always 5024 // created before the child) 5025 // 2. A component's user watchers are run before its render watcher (because 5026 // user watchers are created before the render watcher) 5027 // 3. If a component is destroyed during a parent component's watcher run, 5028 // its watchers can be skipped. 5029 queue.sort(function (a, b) { return a.id - b.id; }); 5030 5031 // do not cache length because more watchers might be pushed 5032 // as we run existing watchers 5033 for (index = 0; index < queue.length; index++) { 5034 watcher = queue[index]; 5035 id = watcher.id; 5036 has[id] = null; 5037 watcher.run(); 5038 // in dev build, check and stop circular updates. 5039 if (false) {} 5040 } 5041 5042 // keep copies of post queues before resetting state 5043 var activatedQueue = activatedChildren.slice(); 5044 var updatedQueue = queue.slice(); 5045 5046 resetSchedulerState(); 5047 5048 // call component updated and activated hooks 5049 callActivatedHooks(activatedQueue); 5050 callUpdateHooks(updatedQueue); 5051 5052 // devtool hook 5053 /* istanbul ignore if */ 5054 if (devtools && config.devtools) { 5055 devtools.emit('flush'); 5056 } 5057 } 5058 5059 function callUpdateHooks (queue) { 5060 var i = queue.length; 5061 while (i--) { 5062 var watcher = queue[i]; 5063 var vm = watcher.vm; 5064 if (vm._watcher === watcher && vm._isMounted) { 5065 callHook(vm, 'updated'); 5066 } 5067 } 5068 } 5069 5070 /** 5071 * Queue a kept-alive component that was activated during patch. 5072 * The queue will be processed after the entire tree has been patched. 5073 */ 5074 function queueActivatedComponent (vm) { 5075 // setting _inactive to false here so that a render function can 5076 // rely on checking whether it's in an inactive tree (e.g. router-view) 5077 vm._inactive = false; 5078 activatedChildren.push(vm); 5079 } 5080 5081 function callActivatedHooks (queue) { 5082 for (var i = 0; i < queue.length; i++) { 5083 queue[i]._inactive = true; 5084 activateChildComponent(queue[i], true /* true */); 5085 } 5086 } 5087 5088 /** 5089 * Push a watcher into the watcher queue. 5090 * Jobs with duplicate IDs will be skipped unless it's 5091 * pushed when the queue is being flushed. 5092 */ 5093 function queueWatcher (watcher) { 5094 var id = watcher.id; 5095 if (has[id] == null) { 5096 has[id] = true; 5097 if (!flushing) { 5098 queue.push(watcher); 5099 } else { 5100 // if already flushing, splice the watcher based on its id 5101 // if already past its id, it will be run next immediately. 5102 var i = queue.length - 1; 5103 while (i > index && queue[i].id > watcher.id) { 5104 i--; 5105 } 5106 queue.splice(i + 1, 0, watcher); 5107 } 5108 // queue the flush 5109 if (!waiting) { 5110 waiting = true; 5111 nextTick(flushSchedulerQueue); 5112 } 5113 } 5114 } 5115 5116 /* */ 5117 5118 var uid$2 = 0; 5119 5120 /** 5121 * A watcher parses an expression, collects dependencies, 5122 * and fires callback when the expression value changes. 5123 * This is used for both the $watch() api and directives. 5124 */ 5125 var Watcher = function Watcher ( 5126 vm, 5127 expOrFn, 5128 cb, 5129 options 5130 ) { 5131 this.vm = vm; 5132 vm._watchers.push(this); 5133 // options 5134 if (options) { 5135 this.deep = !!options.deep; 5136 this.user = !!options.user; 5137 this.lazy = !!options.lazy; 5138 this.sync = !!options.sync; 5139 } else { 5140 this.deep = this.user = this.lazy = this.sync = false; 5141 } 5142 this.cb = cb; 5143 this.id = ++uid$2; // uid for batching 5144 this.active = true; 5145 this.dirty = this.lazy; // for lazy watchers 5146 this.deps = []; 5147 this.newDeps = []; 5148 this.depIds = new _Set(); 5149 this.newDepIds = new _Set(); 5150 this.expression = ''; 5151 // parse expression for getter 5152 if (typeof expOrFn === 'function') { 5153 this.getter = expOrFn; 5154 } else { 5155 this.getter = parsePath(expOrFn); 5156 if (!this.getter) { 5157 this.getter = function () {}; 5158 "production" !== 'production' && warn$1( 5159 "Failed watching path: \"" + expOrFn + "\" " + 5160 'Watcher only accepts simple dot-delimited paths. ' + 5161 'For full control, use a function instead.', 5162 vm 5163 ); 5164 } 5165 } 5166 this.value = this.lazy 5167 ? undefined 5168 : this.get(); 5169 }; 5170 5171 /** 5172 * Evaluate the getter, and re-collect dependencies. 5173 */ 5174 Watcher.prototype.get = function get () { 5175 pushTarget(this); 5176 var value; 5177 var vm = this.vm; 5178 if (this.user) { 5179 try { 5180 value = this.getter.call(vm, vm); 5181 } catch (e) { 5182 handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\"")); 5183 } 5184 } else { 5185 value = this.getter.call(vm, vm); 5186 } 5187 // "touch" every property so they are all tracked as 5188 // dependencies for deep watching 5189 if (this.deep) { 5190 traverse(value); 5191 } 5192 popTarget(); 5193 this.cleanupDeps(); 5194 return value 5195 }; 5196 5197 /** 5198 * Add a dependency to this directive. 5199 */ 5200 Watcher.prototype.addDep = function addDep (dep) { 5201 var id = dep.id; 5202 if (!this.newDepIds.has(id)) { 5203 this.newDepIds.add(id); 5204 this.newDeps.push(dep); 5205 if (!this.depIds.has(id)) { 5206 dep.addSub(this); 5207 } 5208 } 5209 }; 5210 5211 /** 5212 * Clean up for dependency collection. 5213 */ 5214 Watcher.prototype.cleanupDeps = function cleanupDeps () { 5215 var this$1 = this; 5216 5217 var i = this.deps.length; 5218 while (i--) { 5219 var dep = this$1.deps[i]; 5220 if (!this$1.newDepIds.has(dep.id)) { 5221 dep.removeSub(this$1); 5222 } 5223 } 5224 var tmp = this.depIds; 5225 this.depIds = this.newDepIds; 5226 this.newDepIds = tmp; 5227 this.newDepIds.clear(); 5228 tmp = this.deps; 5229 this.deps = this.newDeps; 5230 this.newDeps = tmp; 5231 this.newDeps.length = 0; 5232 }; 5233 5234 /** 5235 * Subscriber interface. 5236 * Will be called when a dependency changes. 5237 */ 5238 Watcher.prototype.update = function update () { 5239 /* istanbul ignore else */ 5240 if (this.lazy) { 5241 this.dirty = true; 5242 } else if (this.sync) { 5243 this.run(); 5244 } else { 5245 queueWatcher(this); 5246 } 5247 }; 5248 5249 /** 5250 * Scheduler job interface. 5251 * Will be called by the scheduler. 5252 */ 5253 Watcher.prototype.run = function run () { 5254 if (this.active) { 5255 var value = this.get(); 5256 if ( 5257 value !== this.value || 5258 // Deep watchers and watchers on Object/Arrays should fire even 5259 // when the value is the same, because the value may 5260 // have mutated. 5261 isObject(value) || 5262 this.deep 5263 ) { 5264 // set new value 5265 var oldValue = this.value; 5266 this.value = value; 5267 if (this.user) { 5268 try { 5269 this.cb.call(this.vm, value, oldValue); 5270 } catch (e) { 5271 handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\"")); 5272 } 5273 } else { 5274 this.cb.call(this.vm, value, oldValue); 5275 } 5276 } 5277 } 5278 }; 5279 5280 /** 5281 * Evaluate the value of the watcher. 5282 * This only gets called for lazy watchers. 5283 */ 5284 Watcher.prototype.evaluate = function evaluate () { 5285 this.value = this.get(); 5286 this.dirty = false; 5287 }; 5288 5289 /** 5290 * Depend on all deps collected by this watcher. 5291 */ 5292 Watcher.prototype.depend = function depend () { 5293 var this$1 = this; 5294 5295 var i = this.deps.length; 5296 while (i--) { 5297 this$1.deps[i].depend(); 5298 } 5299 }; 5300 5301 /** 5302 * Remove self from all dependencies' subscriber list. 5303 */ 5304 Watcher.prototype.teardown = function teardown () { 5305 var this$1 = this; 5306 5307 if (this.active) { 5308 // remove self from vm's watcher list 5309 // this is a somewhat expensive operation so we skip it 5310 // if the vm is being destroyed. 5311 if (!this.vm._isBeingDestroyed) { 5312 remove(this.vm._watchers, this); 5313 } 5314 var i = this.deps.length; 5315 while (i--) { 5316 this$1.deps[i].removeSub(this$1); 5317 } 5318 this.active = false; 5319 } 5320 }; 5321 5322 /** 5323 * Recursively traverse an object to evoke all converted 5324 * getters, so that every nested property inside the object 5325 * is collected as a "deep" dependency. 5326 */ 5327 var seenObjects = new _Set(); 5328 function traverse (val) { 5329 seenObjects.clear(); 5330 _traverse(val, seenObjects); 5331 } 5332 5333 function _traverse (val, seen) { 5334 var i, keys; 5335 var isA = Array.isArray(val); 5336 if ((!isA && !isObject(val)) || !Object.isExtensible(val)) { 5337 return 5338 } 5339 if (val.__ob__) { 5340 var depId = val.__ob__.dep.id; 5341 if (seen.has(depId)) { 5342 return 5343 } 5344 seen.add(depId); 5345 } 5346 if (isA) { 5347 i = val.length; 5348 while (i--) { _traverse(val[i], seen); } 5349 } else { 5350 keys = Object.keys(val); 5351 i = keys.length; 5352 while (i--) { _traverse(val[keys[i]], seen); } 5353 } 5354 } 5355 5356 /* */ 5357 5358 var sharedPropertyDefinition = { 5359 enumerable: true, 5360 configurable: true, 5361 get: noop, 5362 set: noop 5363 }; 5364 5365 function proxy (target, sourceKey, key) { 5366 sharedPropertyDefinition.get = function proxyGetter () { 5367 return this[sourceKey][key] 5368 }; 5369 sharedPropertyDefinition.set = function proxySetter (val) { 5370 this[sourceKey][key] = val; 5371 }; 5372 Object.defineProperty(target, key, sharedPropertyDefinition); 5373 } 5374 5375 function initState (vm) { 5376 vm._watchers = []; 5377 var opts = vm.$options; 5378 if (opts.props) { initProps(vm, opts.props); } 5379 if (opts.methods) { initMethods(vm, opts.methods); } 5380 if (opts.data) { 5381 initData(vm); 5382 } else { 5383 observe(vm._data = {}, true /* asRootData */); 5384 } 5385 if (opts.computed) { initComputed(vm, opts.computed); } 5386 if (opts.watch) { initWatch(vm, opts.watch); } 5387 } 5388 5389 function initProps (vm, propsOptions) { 5390 var propsData = vm.$options.propsData || {}; 5391 var props = vm._props = {}; 5392 // cache prop keys so that future props updates can iterate using Array 5393 // instead of dynamic object key enumeration. 5394 var keys = vm.$options._propKeys = []; 5395 var isRoot = !vm.$parent; 5396 // root instance props should be converted 5397 observerState.shouldConvert = isRoot; 5398 var loop = function ( key ) { 5399 keys.push(key); 5400 var value = validateProp(key, propsOptions, propsData, vm); 5401 /* istanbul ignore else */ 5402 if (false) {} else { 5403 defineReactive$$1(props, key, value); 5404 } 5405 // static props are already proxied on the component's prototype 5406 // during Vue.extend(). We only need to proxy props defined at 5407 // instantiation here. 5408 if (!(key in vm)) { 5409 proxy(vm, "_props", key); 5410 } 5411 }; 5412 5413 for (var key in propsOptions) { loop( key ); } 5414 observerState.shouldConvert = true; 5415 } 5416 5417 function initData (vm) { 5418 var data = vm.$options.data; 5419 data = vm._data = typeof data === 'function' 5420 ? getData(data, vm) 5421 : data || {}; 5422 if (!isPlainObject(data)) { 5423 data = {}; 5424 "production" !== 'production' && warn$1( 5425 'data functions should return an object:\n' + 5426 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', 5427 vm 5428 ); 5429 } 5430 // proxy data on instance 5431 var keys = Object.keys(data); 5432 var props = vm.$options.props; 5433 var i = keys.length; 5434 while (i--) { 5435 if (props && hasOwn(props, keys[i])) { 5436 "production" !== 'production' && warn$1( 5437 "The data property \"" + (keys[i]) + "\" is already declared as a prop. " + 5438 "Use prop default value instead.", 5439 vm 5440 ); 5441 } else if (!isReserved(keys[i])) { 5442 proxy(vm, "_data", keys[i]); 5443 } 5444 } 5445 // observe data 5446 observe(data, true /* asRootData */); 5447 } 5448 5449 function getData (data, vm) { 5450 try { 5451 return data.call(vm) 5452 } catch (e) { 5453 handleError(e, vm, "data()"); 5454 return {} 5455 } 5456 } 5457 5458 var computedWatcherOptions = { lazy: true }; 5459 5460 function initComputed (vm, computed) { 5461 var watchers = vm._computedWatchers = Object.create(null); 5462 5463 for (var key in computed) { 5464 var userDef = computed[key]; 5465 var getter = typeof userDef === 'function' ? userDef : userDef.get; 5466 if (false) {} 5467 // create internal watcher for the computed property. 5468 watchers[key] = new Watcher(vm, getter, noop, computedWatcherOptions); 5469 5470 // component-defined computed properties are already defined on the 5471 // component prototype. We only need to define computed properties defined 5472 // at instantiation here. 5473 if (!(key in vm)) { 5474 defineComputed(vm, key, userDef); 5475 } else if (false) {} 5476 } 5477 } 5478 5479 function defineComputed (target, key, userDef) { 5480 if (typeof userDef === 'function') { 5481 sharedPropertyDefinition.get = createComputedGetter(key); 5482 sharedPropertyDefinition.set = noop; 5483 } else { 5484 sharedPropertyDefinition.get = userDef.get 5485 ? userDef.cache !== false 5486 ? createComputedGetter(key) 5487 : userDef.get 5488 : noop; 5489 sharedPropertyDefinition.set = userDef.set 5490 ? userDef.set 5491 : noop; 5492 } 5493 Object.defineProperty(target, key, sharedPropertyDefinition); 5494 } 5495 5496 function createComputedGetter (key) { 5497 return function computedGetter () { 5498 var watcher = this._computedWatchers && this._computedWatchers[key]; 5499 if (watcher) { 5500 if (watcher.dirty) { 5501 watcher.evaluate(); 5502 } 5503 if (Dep.target) {
5504 watcher.depend(); 5505 } 5506 return watcher.value 5507 } 5508 } 5509 } 5510 5511 function initMethods (vm, methods) { 5512 var props = vm.$options.props; 5513 for (var key in methods) { 5514 vm[key] = methods[key] == null ? noop : bind(methods[key], vm); 5515 if (false) {} 5516 } 5517 } 5518 5519 function initWatch (vm, watch) { 5520 for (var key in watch) { 5521 var handler = watch[key]; 5522 if (Array.isArray(handler)) { 5523 for (var i = 0; i < handler.length; i++) { 5524 createWatcher(vm, key, handler[i]); 5525 } 5526 } else { 5527 createWatcher(vm, key, handler); 5528 } 5529 } 5530 } 5531 5532 function createWatcher (vm, key, handler) { 5533 var options; 5534 if (isPlainObject(handler)) { 5535 options = handler; 5536 handler = handler.handler; 5537 } 5538 if (typeof handler === 'string') { 5539 handler = vm[handler]; 5540 } 5541 vm.$watch(key, handler, options); 5542 } 5543 5544 function stateMixin (Vue) { 5545 // flow somehow has problems with directly declared definition object 5546 // when using Object.defineProperty, so we have to procedurally build up 5547 // the object here. 5548 var dataDef = {}; 5549 dataDef.get = function () { return this._data }; 5550 var propsDef = {}; 5551 propsDef.get = function () { return this._props }; 5552 if (false) {} 5553 Object.defineProperty(Vue.prototype, '$data', dataDef); 5554 Object.defineProperty(Vue.prototype, '$props', propsDef); 5555 5556 Vue.prototype.$set = set; 5557 Vue.prototype.$delete = del; 5558 5559 Vue.prototype.$watch = function ( 5560 expOrFn, 5561 cb, 5562 options 5563 ) { 5564 var vm = this; 5565 options = options || {}; 5566 options.user = true; 5567 var watcher = new Watcher(vm, expOrFn, cb, options); 5568 if (options.immediate) { 5569 cb.call(vm, watcher.value); 5570 } 5571 return function unwatchFn () { 5572 watcher.teardown(); 5573 } 5574 }; 5575 } 5576 5577 /* */ 5578 5579 function initProvide (vm) { 5580 var provide = vm.$options.provide; 5581 if (provide) { 5582 vm._provided = typeof provide === 'function' 5583 ? provide.call(vm) 5584 : provide; 5585 } 5586 } 5587 5588 function initInjections (vm) { 5589 var result = resolveInject(vm.$options.inject, vm); 5590 if (result) { 5591 Object.keys(result).forEach(function (key) { 5592 /* istanbul ignore else */ 5593 if (false) {} else { 5594 defineReactive$$1(vm, key, result[key]); 5595 } 5596 }); 5597 } 5598 } 5599 5600 function resolveInject (inject, vm) { 5601 if (inject) { 5602 // inject is :any because flow is not smart enough to figure out cached 5603 // isArray here 5604 var isArray = Array.isArray(inject); 5605 var result = Object.create(null); 5606 var keys = isArray 5607 ? inject 5608 : hasSymbol 5609 ? Reflect.ownKeys(inject) 5610 : Object.keys(inject); 5611 5612 for (var i = 0; i < keys.length; i++) { 5613 var key = keys[i]; 5614 var provideKey = isArray ? key : inject[key]; 5615 var source = vm; 5616 while (source) { 5617 if (source._provided && provideKey in source._provided) { 5618 result[key] = source._provided[provideKey]; 5619 break 5620 } 5621 source = source.$parent; 5622 } 5623 } 5624 return result 5625 } 5626 } 5627 5628 /* */ 5629 5630 function createFunctionalComponent ( 5631 Ctor, 5632 propsData, 5633 data, 5634 context, 5635 children 5636 ) { 5637 var props = {}; 5638 var propOptions = Ctor.options.props; 5639 if (isDef(propOptions)) { 5640 for (var key in propOptions) { 5641 props[key] = validateProp(key, propOptions, propsData || {}); 5642 } 5643 } else { 5644 if (isDef(data.attrs)) { mergeProps(props, data.attrs); } 5645 if (isDef(data.props)) { mergeProps(props, data.props); } 5646 } 5647 // ensure the createElement function in functional components 5648 // gets a unique context - this is necessary for correct named slot check 5649 var _context = Object.create(context); 5650 var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); }; 5651 var vnode = Ctor.options.render.call(null, h, { 5652 data: data, 5653 props: props, 5654 children: children, 5655 parent: context, 5656 listeners: data.on || {}, 5657 injections: resolveInject(Ctor.options.inject, context), 5658 slots: function () { return resolveSlots(children, context); } 5659 }); 5660 if (vnode instanceof VNode) { 5661 vnode.functionalContext = context; 5662 vnode.functionalOptions = Ctor.options; 5663 if (data.slot) { 5664 (vnode.data || (vnode.data = {})).slot = data.slot; 5665 } 5666 } 5667 return vnode 5668 } 5669 5670 function mergeProps (to, from) { 5671 for (var key in from) { 5672 to[camelize(key)] = from[key]; 5673 } 5674 } 5675 5676 /* */ 5677 5678 // hooks to be invoked on component VNodes during patch
vendor: 10,273 bytes, lines 5679-6032
5679 var componentVNodeHooks = { 5680 init: function init ( 5681 vnode, 5682 hydrating, 5683 parentElm, 5684 refElm 5685 ) { 5686 if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) { 5687 var child = vnode.componentInstance = createComponentInstanceForVnode( 5688 vnode, 5689 activeInstance, 5690 parentElm, 5691 refElm 5692 ); 5693 child.$mount(hydrating ? vnode.elm : undefined, hydrating); 5694 } else if (vnode.data.keepAlive) { 5695 // kept-alive components, treat as a patch 5696 var mountedNode = vnode; // work around flow 5697 componentVNodeHooks.prepatch(mountedNode, mountedNode); 5698 } 5699 }, 5700 5701 prepatch: function prepatch (oldVnode, vnode) { 5702 var options = vnode.componentOptions; 5703 var child = vnode.componentInstance = oldVnode.componentInstance; 5704 updateChildComponent( 5705 child, 5706 options.propsData, // updated props 5707 options.listeners, // updated listeners 5708 vnode, // new parent vnode 5709 options.children // new children 5710 ); 5711 }, 5712 5713 insert: function insert (vnode) { 5714 var context = vnode.context; 5715 var componentInstance = vnode.componentInstance; 5716 if (!componentInstance._isMounted) { 5717 componentInstance._isMounted = true; 5718 callHook(componentInstance, 'mounted'); 5719 } 5720 if (vnode.data.keepAlive) { 5721 if (context._isMounted) { 5722 // vue-router#1212 5723 // During updates, a kept-alive component's child components may 5724 // change, so directly walking the tree here may call activated hooks 5725 // on incorrect children. Instead we push them into a queue which will 5726 // be processed after the whole patch process ended. 5727 queueActivatedComponent(componentInstance); 5728 } else { 5729 activateChildComponent(componentInstance, true /* direct */); 5730 } 5731 } 5732 }, 5733 5734 destroy: function destroy (vnode) { 5735 var componentInstance = vnode.componentInstance; 5736 if (!componentInstance._isDestroyed) { 5737 if (!vnode.data.keepAlive) { 5738 componentInstance.$destroy(); 5739 } else { 5740 deactivateChildComponent(componentInstance, true /* direct */); 5741 } 5742 } 5743 } 5744 }; 5745 5746 var hooksToMerge = Object.keys(componentVNodeHooks); 5747 5748 function createComponent ( 5749 Ctor, 5750 data, 5751 context, 5752 children, 5753 tag 5754 ) { 5755 if (isUndef(Ctor)) { 5756 return 5757 } 5758 5759 var baseCtor = context.$options._base; 5760 5761 // plain options object: turn it into a constructor 5762 if (isObject(Ctor)) { 5763 Ctor = baseCtor.extend(Ctor); 5764 } 5765 5766 // if at this stage it's not a constructor or an async component factory, 5767 // reject. 5768 if (typeof Ctor !== 'function') { 5769 if (false) {} 5770 return 5771 } 5772 5773 // async component 5774 if (isUndef(Ctor.cid)) { 5775 Ctor = resolveAsyncComponent(Ctor, baseCtor, context); 5776 if (Ctor === undefined) { 5777 // return nothing if this is indeed an async component 5778 // wait for the callback to trigger parent update. 5779 return 5780 } 5781 } 5782 5783 // resolve constructor options in case global mixins are applied after 5784 // component constructor creation 5785 resolveConstructorOptions(Ctor); 5786 5787 data = data || {}; 5788 5789 // transform component v-model data into props & events 5790 if (isDef(data.model)) { 5791 transformModel(Ctor.options, data); 5792 } 5793 5794 // extract props 5795 var propsData = extractPropsFromVNodeData(data, Ctor, tag); 5796 5797 // functional component 5798 if (isTrue(Ctor.options.functional)) { 5799 return createFunctionalComponent(Ctor, propsData, data, context, children) 5800 } 5801 5802 // extract listeners, since these needs to be treated as 5803 // child component listeners instead of DOM listeners 5804 var listeners = data.on; 5805 // replace with listeners with .native modifier 5806 data.on = data.nativeOn; 5807 5808 if (isTrue(Ctor.options.abstract)) { 5809 // abstract components do not keep anything 5810 // other than props & listeners 5811 data = {}; 5812 } 5813 5814 // merge component management hooks onto the placeholder node 5815 mergeHooks(data); 5816 5817 // return a placeholder vnode 5818 var name = Ctor.options.name || tag; 5819 var vnode = new VNode( 5820 ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), 5821 data, undefined, undefined, undefined, context, 5822 { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children } 5823 ); 5824 return vnode 5825 } 5826 5827 function createComponentInstanceForVnode ( 5828 vnode, // we know it's MountedComponentVNode but flow doesn't 5829 parent, // activeInstance in lifecycle state 5830 parentElm, 5831 refElm 5832 ) { 5833 var vnodeComponentOptions = vnode.componentOptions; 5834 var options = { 5835 _isComponent: true, 5836 parent: parent, 5837 propsData: vnodeComponentOptions.propsData, 5838 _componentTag: vnodeComponentOptions.tag, 5839 _parentVnode: vnode, 5840 _parentListeners: vnodeComponentOptions.listeners, 5841 _renderChildren: vnodeComponentOptions.children, 5842 _parentElm: parentElm || null, 5843 _refElm: refElm || null 5844 }; 5845 // check inline-template render functions 5846 var inlineTemplate = vnode.data.inlineTemplate; 5847 if (isDef(inlineTemplate)) { 5848 options.render = inlineTemplate.render; 5849 options.staticRenderFns = inlineTemplate.staticRenderFns; 5850 } 5851 return new vnodeComponentOptions.Ctor(options) 5852 } 5853 5854 function mergeHooks (data) { 5855 if (!data.hook) { 5856 data.hook = {}; 5857 } 5858 for (var i = 0; i < hooksToMerge.length; i++) { 5859 var key = hooksToMerge[i]; 5860 var fromParent = data.hook[key]; 5861 var ours = componentVNodeHooks[key]; 5862 data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours; 5863 } 5864 } 5865 5866 function mergeHook$1 (one, two) { 5867 return function (a, b, c, d) { 5868 one(a, b, c, d); 5869 two(a, b, c, d); 5870 } 5871 } 5872 5873 // transform component v-model info (value and callback) into 5874 // prop and event handler respectively. 5875 function transformModel (options, data) { 5876 var prop = (options.model && options.model.prop) || 'value'; 5877 var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value; 5878 var on = data.on || (data.on = {}); 5879 if (isDef(on[event])) { 5880 on[event] = [data.model.callback].concat(on[event]); 5881 } else { 5882 on[event] = data.model.callback; 5883 } 5884 } 5885 5886 /* */ 5887 5888 var SIMPLE_NORMALIZE = 1; 5889 var ALWAYS_NORMALIZE = 2; 5890 5891 // wrapper function for providing a more flexible interface 5892 // without getting yelled at by flow 5893 function createElement ( 5894 context, 5895 tag, 5896 data, 5897 children, 5898 normalizationType, 5899 alwaysNormalize 5900 ) { 5901 if (Array.isArray(data) || isPrimitive(data)) { 5902 normalizationType = children; 5903 children = data; 5904 data = undefined; 5905 } 5906 if (isTrue(alwaysNormalize)) { 5907 normalizationType = ALWAYS_NORMALIZE; 5908 } 5909 return _createElement(context, tag, data, children, normalizationType) 5910 } 5911 5912 function _createElement ( 5913 context, 5914 tag, 5915 data, 5916 children, 5917 normalizationType 5918 ) { 5919 if (isDef(data) && isDef((data).__ob__)) { 5920 "production" !== 'production' && warn$1( 5921 "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 5922 'Always create fresh vnode data objects in each render!', 5923 context 5924 ); 5925 return createEmptyVNode() 5926 } 5927 if (!tag) { 5928 // in case of component :is set to falsy value 5929 return createEmptyVNode() 5930 } 5931 // support single function children as default scoped slot 5932 if (Array.isArray(children) && 5933 typeof children[0] === 'function' 5934 ) { 5935 data = data || {}; 5936 data.scopedSlots = { default: children[0] }; 5937 children.length = 0; 5938 } 5939 if (normalizationType === ALWAYS_NORMALIZE) { 5940 children = normalizeChildren(children); 5941 } else if (normalizationType === SIMPLE_NORMALIZE) { 5942 children = simpleNormalizeChildren(children); 5943 } 5944 var vnode, ns; 5945 if (typeof tag === 'string') { 5946 var Ctor; 5947 ns = config.getTagNamespace(tag); 5948 if (config.isReservedTag(tag)) { 5949 // platform built-in elements 5950 vnode = new VNode( 5951 config.parsePlatformTagName(tag), data, children, 5952 undefined, undefined, context 5953 ); 5954 } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) { 5955 // component 5956 vnode = createComponent(Ctor, data, context, children, tag); 5957 } else { 5958 // unknown or unlisted namespaced elements 5959 // check at runtime because it may get assigned a namespace when its 5960 // parent normalizes children 5961 vnode = new VNode( 5962 tag, data, children, 5963 undefined, undefined, context 5964 ); 5965 } 5966 } else { 5967 // direct component options / constructor 5968 vnode = createComponent(tag, data, context, children); 5969 } 5970 if (isDef(vnode)) { 5971 if (ns) { applyNS(vnode, ns); } 5972 return vnode 5973 } else { 5974 return createEmptyVNode() 5975 } 5976 } 5977 5978 function applyNS (vnode, ns) { 5979 vnode.ns = ns; 5980 if (vnode.tag === 'foreignObject') { 5981 // use default namespace inside foreignObject 5982 return 5983 } 5984 if (isDef(vnode.children)) { 5985 for (var i = 0, l = vnode.children.length; i < l; i++) { 5986 var child = vnode.children[i]; 5987 if (isDef(child.tag) && isUndef(child.ns)) { 5988 applyNS(child, ns); 5989 } 5990 } 5991 } 5992 } 5993 5994 /* */ 5995 5996 /** 5997 * Runtime helper for rendering v-for lists. 5998 */ 5999 function renderList ( 6000 val, 6001 render 6002 ) { 6003 var ret, i, l, keys, key; 6004 if (Array.isArray(val) || typeof val === 'string') { 6005 ret = new Array(val.length); 6006 for (i = 0, l = val.length; i < l; i++) { 6007 ret[i] = render(val[i], i); 6008 } 6009 } else if (typeof val === 'number') { 6010 ret = new Array(val); 6011 for (i = 0; i < val; i++) { 6012 ret[i] = render(i + 1, i); 6013 } 6014 } else if (isObject(val)) { 6015 keys = Object.keys(val); 6016 ret = new Array(keys.length); 6017 for (i = 0, l = keys.length; i < l; i++) { 6018 key = keys[i]; 6019 ret[i] = render(val[key], key, i); 6020 } 6021 } 6022 if (isDef(ret)) { 6023 (ret)._isVList = true; 6024 } 6025 return ret 6026 } 6027 6028 /* */ 6029 6030 /** 6031 * Runtime helper for rendering <slot> 6032 */
6033 function renderSlot ( 6034 name, 6035 fallback, 6036 props, 6037 bindObject 6038 ) { 6039 var scopedSlotFn = this.$scopedSlots[name]; 6040 if (scopedSlotFn) { // scoped slot 6041 props = props || {}; 6042 if (bindObject) { 6043 extend(props, bindObject); 6044 } 6045 return scopedSlotFn(props) || fallback 6046 } else { 6047 var slotNodes = this.$slots[name]; 6048 // warn duplicate slot usage 6049 if (slotNodes && "production" !== 'production') { 6050 slotNodes._rendered && warn$1( 6051 "Duplicate presence of slot \"" + name + "\" found in the same render tree " + 6052 "- this will likely cause render errors.", 6053 this 6054 ); 6055 slotNodes._rendered = true; 6056 } 6057 return slotNodes || fallback 6058 } 6059 } 6060 6061 /* */ 6062 6063 /** 6064 * Runtime helper for resolving filters 6065 */ 6066 function resolveFilter (id) { 6067 return resolveAsset(this.$options, 'filters', id, true) || identity 6068 } 6069 6070 /* */ 6071 6072 /** 6073 * Runtime helper for checking keyCodes from config. 6074 */ 6075 function checkKeyCodes ( 6076 eventKeyCode, 6077 key, 6078 builtInAlias 6079 ) { 6080 var keyCodes = config.keyCodes[key] || builtInAlias; 6081 if (Array.isArray(keyCodes)) { 6082 return keyCodes.indexOf(eventKeyCode) === -1 6083 } else { 6084 return keyCodes !== eventKeyCode 6085 } 6086 } 6087 6088 /* */ 6089 6090 /** 6091 * Runtime helper for merging v-bind="object" into a VNode's data. 6092 */ 6093 function bindObjectProps ( 6094 data, 6095 tag, 6096 value, 6097 asProp 6098 ) { 6099 if (value) { 6100 if (!isObject(value)) { 6101 "production" !== 'production' && warn$1( 6102 'v-bind without argument expects an Object or Array value', 6103 this 6104 ); 6105 } else { 6106 if (Array.isArray(value)) { 6107 value = toObject(value); 6108 } 6109 var hash; 6110 for (var key in value) { 6111 if (key === 'class' || key === 'style') { 6112 hash = data; 6113 } else { 6114 var type = data.attrs && data.attrs.type; 6115 hash = asProp || config.mustUseProp(tag, type, key) 6116 ? data.domProps || (data.domProps = {}) 6117 : data.attrs || (data.attrs = {}); 6118 } 6119 if (!(key in hash)) { 6120 hash[key] = value[key]; 6121 } 6122 } 6123 } 6124 } 6125 return data 6126 } 6127 6128 /* */ 6129 6130 /** 6131 * Runtime helper for rendering static trees. 6132 */
vendor: 8,867 bytes, lines 6133-6427
6133 function renderStatic ( 6134 index, 6135 isInFor 6136 ) { 6137 var tree = this._staticTrees[index]; 6138 // if has already-rendered static tree and not inside v-for, 6139 // we can reuse the same tree by doing a shallow clone. 6140 if (tree && !isInFor) { 6141 return Array.isArray(tree) 6142 ? cloneVNodes(tree) 6143 : cloneVNode(tree) 6144 } 6145 // otherwise, render a fresh tree. 6146 tree = this._staticTrees[index] = 6147 this.$options.staticRenderFns[index].call(this._renderProxy); 6148 markStatic(tree, ("__static__" + index), false); 6149 return tree 6150 } 6151 6152 /** 6153 * Runtime helper for v-once. 6154 * Effectively it means marking the node as static with a unique key. 6155 */ 6156 function markOnce ( 6157 tree, 6158 index, 6159 key 6160 ) { 6161 markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true); 6162 return tree 6163 } 6164 6165 function markStatic ( 6166 tree, 6167 key, 6168 isOnce 6169 ) { 6170 if (Array.isArray(tree)) { 6171 for (var i = 0; i < tree.length; i++) { 6172 if (tree[i] && typeof tree[i] !== 'string') { 6173 markStaticNode(tree[i], (key + "_" + i), isOnce); 6174 } 6175 } 6176 } else { 6177 markStaticNode(tree, key, isOnce); 6178 } 6179 } 6180 6181 function markStaticNode (node, key, isOnce) { 6182 node.isStatic = true; 6183 node.key = key; 6184 node.isOnce = isOnce; 6185 } 6186 6187 /* */ 6188 6189 function initRender (vm) { 6190 vm._vnode = null; // the root of the child tree 6191 vm._staticTrees = null; 6192 var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree 6193 var renderContext = parentVnode && parentVnode.context; 6194 vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext); 6195 vm.$scopedSlots = emptyObject; 6196 // bind the createElement fn to this instance 6197 // so that we get proper render context inside it. 6198 // args order: tag, data, children, normalizationType, alwaysNormalize 6199 // internal version is used by render functions compiled from templates 6200 vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); }; 6201 // normalization is always applied for the public version, used in 6202 // user-written render functions. 6203 vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); }; 6204 } 6205 6206 function renderMixin (Vue) { 6207 Vue.prototype.$nextTick = function (fn) { 6208 return nextTick(fn, this) 6209 }; 6210 6211 Vue.prototype._render = function () { 6212 var vm = this; 6213 var ref = vm.$options; 6214 var render = ref.render; 6215 var staticRenderFns = ref.staticRenderFns; 6216 var _parentVnode = ref._parentVnode; 6217 6218 if (vm._isMounted) { 6219 // clone slot nodes on re-renders 6220 for (var key in vm.$slots) { 6221 vm.$slots[key] = cloneVNodes(vm.$slots[key]); 6222 } 6223 } 6224 6225 vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject; 6226 6227 if (staticRenderFns && !vm._staticTrees) { 6228 vm._staticTrees = []; 6229 } 6230 // set parent vnode. this allows render functions to have access 6231 // to the data on the placeholder node. 6232 vm.$vnode = _parentVnode; 6233 // render self 6234 var vnode; 6235 try { 6236 vnode = render.call(vm._renderProxy, vm.$createElement); 6237 } catch (e) { 6238 handleError(e, vm, "render function"); 6239 // return error render result, 6240 // or previous vnode to prevent render error causing blank component 6241 /* istanbul ignore else */ 6242 if (false) {} else { 6243 vnode = vm._vnode; 6244 } 6245 } 6246 // return empty vnode in case the render function errored out 6247 if (!(vnode instanceof VNode)) { 6248 if (false) {} 6249 vnode = createEmptyVNode(); 6250 } 6251 // set parent 6252 vnode.parent = _parentVnode; 6253 return vnode 6254 }; 6255 6256 // internal render helpers. 6257 // these are exposed on the instance prototype to reduce generated render 6258 // code size. 6259 Vue.prototype._o = markOnce; 6260 Vue.prototype._n = toNumber; 6261 Vue.prototype._s = toString; 6262 Vue.prototype._l = renderList; 6263 Vue.prototype._t = renderSlot; 6264 Vue.prototype._q = looseEqual; 6265 Vue.prototype._i = looseIndexOf; 6266 Vue.prototype._m = renderStatic; 6267 Vue.prototype._f = resolveFilter; 6268 Vue.prototype._k = checkKeyCodes; 6269 Vue.prototype._b = bindObjectProps; 6270 Vue.prototype._v = createTextVNode; 6271 Vue.prototype._e = createEmptyVNode; 6272 Vue.prototype._u = resolveScopedSlots; 6273 } 6274 6275 /* */ 6276 6277 var uid = 0; 6278 6279 function initMixin (Vue) { 6280 Vue.prototype._init = function (options) { 6281 var vm = this; 6282 // a uid 6283 vm._uid = uid++; 6284 6285 var startTag, endTag; 6286 /* istanbul ignore if */ 6287 if (false) {} 6288 6289 // a flag to avoid this being observed 6290 vm._isVue = true; 6291 // merge options 6292 if (options && options._isComponent) { 6293 // optimize internal component instantiation 6294 // since dynamic options merging is pretty slow, and none of the 6295 // internal component options needs special treatment. 6296 initInternalComponent(vm, options); 6297 } else { 6298 vm.$options = mergeOptions( 6299 resolveConstructorOptions(vm.constructor), 6300 options || {}, 6301 vm 6302 ); 6303 } 6304 /* istanbul ignore else */ 6305 if (false) {} else { 6306 vm._renderProxy = vm; 6307 } 6308 // expose real self 6309 vm._self = vm; 6310 initLifecycle(vm); 6311 initEvents(vm); 6312 initRender(vm); 6313 callHook(vm, 'beforeCreate'); 6314 initInjections(vm); // resolve injections before data/props 6315 initState(vm); 6316 initProvide(vm); // resolve provide after data/props 6317 callHook(vm, 'created'); 6318 6319 /* istanbul ignore if */ 6320 if (false) {} 6321 6322 if (vm.$options.el) { 6323 vm.$mount(vm.$options.el); 6324 } 6325 }; 6326 } 6327 6328 function initInternalComponent (vm, options) { 6329 var opts = vm.$options = Object.create(vm.constructor.options); 6330 // doing this because it's faster than dynamic enumeration. 6331 opts.parent = options.parent; 6332 opts.propsData = options.propsData; 6333 opts._parentVnode = options._parentVnode; 6334 opts._parentListeners = options._parentListeners; 6335 opts._renderChildren = options._renderChildren; 6336 opts._componentTag = options._componentTag; 6337 opts._parentElm = options._parentElm; 6338 opts._refElm = options._refElm; 6339 if (options.render) { 6340 opts.render = options.render; 6341 opts.staticRenderFns = options.staticRenderFns; 6342 } 6343 } 6344 6345 function resolveConstructorOptions (Ctor) { 6346 var options = Ctor.options; 6347 if (Ctor.super) { 6348 var superOptions = resolveConstructorOptions(Ctor.super); 6349 var cachedSuperOptions = Ctor.superOptions; 6350 if (superOptions !== cachedSuperOptions) { 6351 // super option changed, 6352 // need to resolve new options. 6353 Ctor.superOptions = superOptions; 6354 // check if there are any late-modified/attached options (#4976) 6355 var modifiedOptions = resolveModifiedOptions(Ctor); 6356 // update base extend options 6357 if (modifiedOptions) { 6358 extend(Ctor.extendOptions, modifiedOptions); 6359 } 6360 options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); 6361 if (options.name) { 6362 options.components[options.name] = Ctor; 6363 } 6364 } 6365 } 6366 return options 6367 } 6368 6369 function resolveModifiedOptions (Ctor) { 6370 var modified; 6371 var latest = Ctor.options; 6372 var extended = Ctor.extendOptions; 6373 var sealed = Ctor.sealedOptions; 6374 for (var key in latest) { 6375 if (latest[key] !== sealed[key]) { 6376 if (!modified) { modified = {}; } 6377 modified[key] = dedupe(latest[key], extended[key], sealed[key]); 6378 } 6379 } 6380 return modified 6381 } 6382 6383 function dedupe (latest, extended, sealed) { 6384 // compare latest and sealed to ensure lifecycle hooks won't be duplicated 6385 // between merges 6386 if (Array.isArray(latest)) { 6387 var res = []; 6388 sealed = Array.isArray(sealed) ? sealed : [sealed]; 6389 extended = Array.isArray(extended) ? extended : [extended]; 6390 for (var i = 0; i < latest.length; i++) { 6391 // push original options and not sealed options to exclude duplicated options 6392 if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) { 6393 res.push(latest[i]); 6394 } 6395 } 6396 return res 6397 } else { 6398 return latest 6399 } 6400 } 6401 6402 function Vue$3 (options) { 6403 if (false 6404 ) {} 6405 this._init(options); 6406 } 6407 6408 initMixin(Vue$3); 6409 stateMixin(Vue$3); 6410 eventsMixin(Vue$3); 6411 lifecycleMixin(Vue$3); 6412 renderMixin(Vue$3); 6413 6414 /* */ 6415 6416 function initUse (Vue) { 6417 Vue.use = function (plugin) { 6418 /* istanbul ignore if */ 6419 if (plugin.installed) { 6420 return this 6421 } 6422 // additional parameters 6423 var args = toArray(arguments, 1); 6424 args.unshift(this); 6425 if (typeof plugin.install === 'function') { 6426 plugin.install.apply(plugin, args); 6427 } else if (typeof plugin === 'function') {
vendor: 2,362 bytes, lines 6428-6513
6428 plugin.apply(null, args); 6429 } 6430 plugin.installed = true; 6431 return this 6432 }; 6433 } 6434 6435 /* */ 6436 6437 function initMixin$1 (Vue) { 6438 Vue.mixin = function (mixin) { 6439 this.options = mergeOptions(this.options, mixin); 6440 return this 6441 }; 6442 } 6443 6444 /* */ 6445 6446 function initExtend (Vue) { 6447 /** 6448 * Each instance constructor, including Vue, has a unique 6449 * cid. This enables us to create wrapped "child 6450 * constructors" for prototypal inheritance and cache them. 6451 */ 6452 Vue.cid = 0; 6453 var cid = 1; 6454 6455 /** 6456 * Class inheritance 6457 */ 6458 Vue.extend = function (extendOptions) { 6459 extendOptions = extendOptions || {}; 6460 var Super = this; 6461 var SuperId = Super.cid; 6462 var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); 6463 if (cachedCtors[SuperId]) { 6464 return cachedCtors[SuperId] 6465 } 6466 6467 var name = extendOptions.name || Super.options.name; 6468 if (false) {} 6469 6470 var Sub = function VueComponent (options) { 6471 this._init(options); 6472 }; 6473 Sub.prototype = Object.create(Super.prototype); 6474 Sub.prototype.constructor = Sub; 6475 Sub.cid = cid++; 6476 Sub.options = mergeOptions( 6477 Super.options, 6478 extendOptions 6479 ); 6480 Sub['super'] = Super; 6481 6482 // For props and computed properties, we define the proxy getters on 6483 // the Vue instances at extension time, on the extended prototype. This 6484 // avoids Object.defineProperty calls for each instance created. 6485 if (Sub.options.props) { 6486 initProps$1(Sub); 6487 } 6488 if (Sub.options.computed) { 6489 initComputed$1(Sub); 6490 } 6491 6492 // allow further extension/mixin/plugin usage 6493 Sub.extend = Super.extend; 6494 Sub.mixin = Super.mixin; 6495 Sub.use = Super.use; 6496 6497 // create asset registers, so extended classes 6498 // can have their private assets too. 6499 ASSET_TYPES.forEach(function (type) { 6500 Sub[type] = Super[type]; 6501 }); 6502 // enable recursive self-lookup 6503 if (name) { 6504 Sub.options.components[name] = Sub; 6505 } 6506 6507 // keep a reference to the super options at extension time. 6508 // later at instantiation we can check if Super's options have 6509 // been updated. 6510 Sub.superOptions = Super.options; 6511 Sub.extendOptions = extendOptions; 6512 Sub.sealedOptions = extend({}, Sub.options); 6513
vendor: 77,504 bytes, lines 6514-9161
6514 // cache constructor 6515 cachedCtors[SuperId] = Sub; 6516 return Sub 6517 }; 6518 } 6519 6520 function initProps$1 (Comp) { 6521 var props = Comp.options.props; 6522 for (var key in props) { 6523 proxy(Comp.prototype, "_props", key); 6524 } 6525 } 6526 6527 function initComputed$1 (Comp) { 6528 var computed = Comp.options.computed; 6529 for (var key in computed) { 6530 defineComputed(Comp.prototype, key, computed[key]); 6531 } 6532 } 6533 6534 /* */ 6535 6536 function initAssetRegisters (Vue) { 6537 /** 6538 * Create asset registration methods. 6539 */ 6540 ASSET_TYPES.forEach(function (type) { 6541 Vue[type] = function ( 6542 id, 6543 definition 6544 ) { 6545 if (!definition) { 6546 return this.options[type + 's'][id] 6547 } else { 6548 /* istanbul ignore if */ 6549 if (false) {} 6550 if (type === 'component' && isPlainObject(definition)) { 6551 definition.name = definition.name || id; 6552 definition = this.options._base.extend(definition); 6553 } 6554 if (type === 'directive' && typeof definition === 'function') { 6555 definition = { bind: definition, update: definition }; 6556 } 6557 this.options[type + 's'][id] = definition; 6558 return definition 6559 } 6560 }; 6561 }); 6562 } 6563 6564 /* */ 6565 6566 var patternTypes = [String, RegExp]; 6567 6568 function getComponentName (opts) { 6569 return opts && (opts.Ctor.options.name || opts.tag) 6570 } 6571 6572 function matches (pattern, name) { 6573 if (typeof pattern === 'string') { 6574 return pattern.split(',').indexOf(name) > -1 6575 } else if (isRegExp(pattern)) { 6576 return pattern.test(name) 6577 } 6578 /* istanbul ignore next */ 6579 return false 6580 } 6581 6582 function pruneCache (cache, current, filter) { 6583 for (var key in cache) { 6584 var cachedNode = cache[key]; 6585 if (cachedNode) { 6586 var name = getComponentName(cachedNode.componentOptions); 6587 if (name && !filter(name)) { 6588 if (cachedNode !== current) { 6589 pruneCacheEntry(cachedNode); 6590 } 6591 cache[key] = null; 6592 } 6593 } 6594 } 6595 } 6596 6597 function pruneCacheEntry (vnode) { 6598 if (vnode) { 6599 vnode.componentInstance.$destroy(); 6600 } 6601 } 6602 6603 var KeepAlive = { 6604 name: 'keep-alive', 6605 abstract: true, 6606 6607 props: { 6608 include: patternTypes, 6609 exclude: patternTypes 6610 }, 6611 6612 created: function created () { 6613 this.cache = Object.create(null); 6614 }, 6615 6616 destroyed: function destroyed () { 6617 var this$1 = this; 6618 6619 for (var key in this$1.cache) { 6620 pruneCacheEntry(this$1.cache[key]); 6621 } 6622 }, 6623 6624 watch: { 6625 include: function include (val) { 6626 pruneCache(this.cache, this._vnode, function (name) { return matches(val, name); }); 6627 }, 6628 exclude: function exclude (val) { 6629 pruneCache(this.cache, this._vnode, function (name) { return !matches(val, name); }); 6630 } 6631 }, 6632 6633 render: function render () { 6634 var vnode = getFirstComponentChild(this.$slots.default); 6635 var componentOptions = vnode && vnode.componentOptions; 6636 if (componentOptions) { 6637 // check pattern 6638 var name = getComponentName(componentOptions); 6639 if (name && ( 6640 (this.include && !matches(this.include, name)) || 6641 (this.exclude && matches(this.exclude, name)) 6642 )) { 6643 return vnode 6644 } 6645 var key = vnode.key == null 6646 // same constructor may get registered as different local components 6647 // so cid alone is not enough (#3269) 6648 ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '') 6649 : vnode.key; 6650 if (this.cache[key]) { 6651 vnode.componentInstance = this.cache[key].componentInstance; 6652 } else { 6653 this.cache[key] = vnode; 6654 } 6655 vnode.data.keepAlive = true; 6656 } 6657 return vnode 6658 } 6659 }; 6660 6661 var builtInComponents = { 6662 KeepAlive: KeepAlive 6663 }; 6664 6665 /* */ 6666 6667 function initGlobalAPI (Vue) { 6668 // config 6669 var configDef = {}; 6670 configDef.get = function () { return config; }; 6671 if (false) {} 6672 Object.defineProperty(Vue, 'config', configDef); 6673 6674 // exposed util methods. 6675 // NOTE: these are not considered part of the public API - avoid relying on 6676 // them unless you are aware of the risk. 6677 Vue.util = { 6678 warn: warn$1, 6679 extend: extend, 6680 mergeOptions: mergeOptions, 6681 defineReactive: defineReactive$$1 6682 }; 6683 6684 Vue.set = set; 6685 Vue.delete = del; 6686 Vue.nextTick = nextTick; 6687 6688 Vue.options = Object.create(null); 6689 ASSET_TYPES.forEach(function (type) { 6690 Vue.options[type + 's'] = Object.create(null); 6691 }); 6692 6693 // this is used to identify the "base" constructor to extend all plain-object 6694 // components with in Weex's multi-instance scenarios. 6695 Vue.options._base = Vue; 6696 6697 extend(Vue.options.components, builtInComponents); 6698 6699 initUse(Vue); 6700 initMixin$1(Vue); 6701 initExtend(Vue); 6702 initAssetRegisters(Vue); 6703 } 6704 6705 initGlobalAPI(Vue$3); 6706 6707 Object.defineProperty(Vue$3.prototype, '$isServer', { 6708 get: isServerRendering 6709 }); 6710 6711 Object.defineProperty(Vue$3.prototype, '$ssrContext', { 6712 get: function get () { 6713 /* istanbul ignore next */ 6714 return this.$vnode.ssrContext 6715 } 6716 }); 6717 6718 Vue$3.version = '2.3.3'; 6719 6720 /* */ 6721 6722 // these are reserved for web because they are directly compiled away 6723 // during template compilation 6724 var isReservedAttr = makeMap('style,class'); 6725 6726 // attributes that should be using props for binding 6727 var acceptValue = makeMap('input,textarea,option,select'); 6728 var mustUseProp = function (tag, type, attr) { 6729 return ( 6730 (attr === 'value' && acceptValue(tag)) && type !== 'button' || 6731 (attr === 'selected' && tag === 'option') || 6732 (attr === 'checked' && tag === 'input') || 6733 (attr === 'muted' && tag === 'video') 6734 ) 6735 }; 6736 6737 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); 6738 6739 var isBooleanAttr = makeMap( 6740 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 6741 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 6742 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 6743 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 6744 'required,reversed,scoped,seamless,selected,sortable,translate,' + 6745 'truespeed,typemustmatch,visible' 6746 ); 6747 6748 var xlinkNS = 'http://www.w3.org/1999/xlink'; 6749 6750 var isXlink = function (name) { 6751 return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' 6752 }; 6753 6754 var getXlinkProp = function (name) { 6755 return isXlink(name) ? name.slice(6, name.length) : '' 6756 }; 6757 6758 var isFalsyAttrValue = function (val) { 6759 return val == null || val === false 6760 }; 6761 6762 /* */ 6763 6764 function genClassForVnode (vnode) { 6765 var data = vnode.data; 6766 var parentNode = vnode; 6767 var childNode = vnode; 6768 while (isDef(childNode.componentInstance)) { 6769 childNode = childNode.componentInstance._vnode; 6770 if (childNode.data) { 6771 data = mergeClassData(childNode.data, data); 6772 } 6773 } 6774 while (isDef(parentNode = parentNode.parent)) { 6775 if (parentNode.data) { 6776 data = mergeClassData(data, parentNode.data); 6777 } 6778 } 6779 return genClassFromData(data) 6780 } 6781 6782 function mergeClassData (child, parent) { 6783 return { 6784 staticClass: concat(child.staticClass, parent.staticClass), 6785 class: isDef(child.class) 6786 ? [child.class, parent.class] 6787 : parent.class 6788 } 6789 } 6790 6791 function genClassFromData (data) { 6792 var dynamicClass = data.class; 6793 var staticClass = data.staticClass; 6794 if (isDef(staticClass) || isDef(dynamicClass)) { 6795 return concat(staticClass, stringifyClass(dynamicClass)) 6796 } 6797 /* istanbul ignore next */ 6798 return '' 6799 } 6800 6801 function concat (a, b) { 6802 return a ? b ? (a + ' ' + b) : a : (b || '') 6803 } 6804 6805 function stringifyClass (value) { 6806 if (isUndef(value)) { 6807 return '' 6808 } 6809 if (typeof value === 'string') { 6810 return value 6811 } 6812 var res = ''; 6813 if (Array.isArray(value)) { 6814 var stringified; 6815 for (var i = 0, l = value.length; i < l; i++) { 6816 if (isDef(value[i])) { 6817 if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') { 6818 res += stringified + ' '; 6819 } 6820 } 6821 } 6822 return res.slice(0, -1) 6823 } 6824 if (isObject(value)) { 6825 for (var key in value) { 6826 if (value[key]) { res += key + ' '; } 6827 } 6828 return res.slice(0, -1) 6829 } 6830 /* istanbul ignore next */ 6831 return res 6832 } 6833 6834 /* */ 6835 6836 var namespaceMap = { 6837 svg: 'http://www.w3.org/2000/svg', 6838 math: 'http://www.w3.org/1998/Math/MathML' 6839 }; 6840 6841 var isHTMLTag = makeMap( 6842 'html,body,base,head,link,meta,style,title,' + 6843 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 6844 'div,dd,dl,dt,figcaption,figure,hr,img,li,main,ol,p,pre,ul,' + 6845 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 6846 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 6847 'embed,object,param,source,canvas,script,noscript,del,ins,' + 6848 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 6849 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 6850 'output,progress,select,textarea,' + 6851 'details,dialog,menu,menuitem,summary,' + 6852 'content,element,shadow,template' 6853 ); 6854 6855 // this map is intentionally selective, only covering SVG elements that may 6856 // contain child elements. 6857 var isSVG = makeMap( 6858 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 6859 'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 6860 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', 6861 true 6862 ); 6863 6864 6865 6866 var isReservedTag = function (tag) { 6867 return isHTMLTag(tag) || isSVG(tag) 6868 }; 6869 6870 function getTagNamespace (tag) { 6871 if (isSVG(tag)) { 6872 return 'svg' 6873 } 6874 // basic support for MathML 6875 // note it doesn't support other MathML elements being component roots 6876 if (tag === 'math') { 6877 return 'math' 6878 } 6879 } 6880 6881 var unknownElementCache = Object.create(null); 6882 function isUnknownElement (tag) { 6883 /* istanbul ignore if */ 6884 if (!inBrowser) { 6885 return true 6886 } 6887 if (isReservedTag(tag)) { 6888 return false 6889 } 6890 tag = tag.toLowerCase(); 6891 /* istanbul ignore if */ 6892 if (unknownElementCache[tag] != null) { 6893 return unknownElementCache[tag] 6894 } 6895 var el = document.createElement(tag); 6896 if (tag.indexOf('-') > -1) { 6897 // http://stackoverflow.com/a/28210364/1070244 6898 return (unknownElementCache[tag] = ( 6899 el.constructor === window.HTMLUnknownElement || 6900 el.constructor === window.HTMLElement 6901 )) 6902 } else { 6903 return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) 6904 } 6905 } 6906 6907 /* */ 6908 6909 /** 6910 * Query an element selector if it's not an element already. 6911 */ 6912 function query (el) { 6913 if (typeof el === 'string') { 6914 var selected = document.querySelector(el); 6915 if (!selected) { 6916 "production" !== 'production' && warn$1( 6917 'Cannot find element: ' + el 6918 ); 6919 return document.createElement('div') 6920 } 6921 return selected 6922 } else { 6923 return el 6924 } 6925 } 6926 6927 /* */ 6928 6929 function createElement$1 (tagName, vnode) { 6930 var elm = document.createElement(tagName); 6931 if (tagName !== 'select') { 6932 return elm 6933 } 6934 // false or null will remove the attribute but undefined will not 6935 if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) { 6936 elm.setAttribute('multiple', 'multiple'); 6937 } 6938 return elm 6939 } 6940 6941 function createElementNS (namespace, tagName) { 6942 return document.createElementNS(namespaceMap[namespace], tagName) 6943 } 6944 6945 function createTextNode (text) { 6946 return document.createTextNode(text) 6947 } 6948 6949 function createComment (text) { 6950 return document.createComment(text) 6951 } 6952 6953 function insertBefore (parentNode, newNode, referenceNode) { 6954 parentNode.insertBefore(newNode, referenceNode); 6955 } 6956 6957 function removeChild (node, child) { 6958 node.removeChild(child); 6959 } 6960 6961 function appendChild (node, child) { 6962 node.appendChild(child); 6963 } 6964 6965 function parentNode (node) { 6966 return node.parentNode 6967 } 6968 6969 function nextSibling (node) { 6970 return node.nextSibling 6971 } 6972 6973 function tagName (node) { 6974 return node.tagName 6975 } 6976 6977 function setTextContent (node, text) { 6978 node.textContent = text; 6979 } 6980 6981 function setAttribute (node, key, val) { 6982 node.setAttribute(key, val); 6983 } 6984 6985 6986 var nodeOps = Object.freeze({ 6987 createElement: createElement$1, 6988 createElementNS: createElementNS, 6989 createTextNode: createTextNode, 6990 createComment: createComment, 6991 insertBefore: insertBefore, 6992 removeChild: removeChild, 6993 appendChild: appendChild, 6994 parentNode: parentNode, 6995 nextSibling: nextSibling, 6996 tagName: tagName, 6997 setTextContent: setTextContent, 6998 setAttribute: setAttribute 6999 }); 7000 7001 /* */ 7002 7003 var ref = { 7004 create: function create (_, vnode) { 7005 registerRef(vnode); 7006 }, 7007 update: function update (oldVnode, vnode) { 7008 if (oldVnode.data.ref !== vnode.data.ref) { 7009 registerRef(oldVnode, true); 7010 registerRef(vnode); 7011 } 7012 }, 7013 destroy: function destroy (vnode) { 7014 registerRef(vnode, true); 7015 } 7016 }; 7017 7018 function registerRef (vnode, isRemoval) { 7019 var key = vnode.data.ref; 7020 if (!key) { return } 7021 7022 var vm = vnode.context; 7023 var ref = vnode.componentInstance || vnode.elm; 7024 var refs = vm.$refs; 7025 if (isRemoval) { 7026 if (Array.isArray(refs[key])) { 7027 remove(refs[key], ref); 7028 } else if (refs[key] === ref) { 7029 refs[key] = undefined; 7030 } 7031 } else { 7032 if (vnode.data.refInFor) { 7033 if (Array.isArray(refs[key]) && refs[key].indexOf(ref) < 0) { 7034 refs[key].push(ref); 7035 } else { 7036 refs[key] = [ref]; 7037 } 7038 } else { 7039 refs[key] = ref; 7040 } 7041 } 7042 } 7043 7044 /** 7045 * Virtual DOM patching algorithm based on Snabbdom by 7046 * Simon Friis Vindum (@paldepind) 7047 * Licensed under the MIT License 7048 * https://github.com/paldepind/snabbdom/blob/master/LICENSE 7049 * 7050 * modified by Evan You (@yyx990803) 7051 * 7052 7053 /* 7054 * Not type-checking this because this file is perf-critical and the cost 7055 * of making flow understand it is not worth it. 7056 */ 7057 7058 var emptyNode = new VNode('', {}, []); 7059 7060 var hooks = ['create', 'activate', 'update', 'remove', 'destroy']; 7061 7062 function sameVnode (a, b) { 7063 return ( 7064 a.key === b.key && 7065 a.tag === b.tag && 7066 a.isComment === b.isComment && 7067 isDef(a.data) === isDef(b.data) && 7068 sameInputType(a, b) 7069 ) 7070 } 7071 7072 // Some browsers do not support dynamically changing type for <input> 7073 // so they need to be treated as different nodes 7074 function sameInputType (a, b) { 7075 if (a.tag !== 'input') { return true } 7076 var i; 7077 var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; 7078 var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; 7079 return typeA === typeB 7080 } 7081 7082 function createKeyToOldIdx (children, beginIdx, endIdx) { 7083 var i, key; 7084 var map = {}; 7085 for (i = beginIdx; i <= endIdx; ++i) { 7086 key = children[i].key; 7087 if (isDef(key)) { map[key] = i; } 7088 } 7089 return map 7090 } 7091 7092 function createPatchFunction (backend) { 7093 var i, j; 7094 var cbs = {}; 7095 7096 var modules = backend.modules; 7097 var nodeOps = backend.nodeOps; 7098 7099 for (i = 0; i < hooks.length; ++i) { 7100 cbs[hooks[i]] = []; 7101 for (j = 0; j < modules.length; ++j) { 7102 if (isDef(modules[j][hooks[i]])) { 7103 cbs[hooks[i]].push(modules[j][hooks[i]]); 7104 } 7105 } 7106 } 7107 7108 function emptyNodeAt (elm) { 7109 return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm) 7110 } 7111 7112 function createRmCb (childElm, listeners) { 7113 function remove$$1 () { 7114 if (--remove$$1.listeners === 0) { 7115 removeNode(childElm); 7116 } 7117 } 7118 remove$$1.listeners = listeners; 7119 return remove$$1 7120 } 7121 7122 function removeNode (el) { 7123 var parent = nodeOps.parentNode(el); 7124 // element may have already been removed due to v-html / v-text 7125 if (isDef(parent)) { 7126 nodeOps.removeChild(parent, el); 7127 } 7128 } 7129 7130 var inPre = 0; 7131 function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) { 7132 vnode.isRootInsert = !nested; // for transition enter check 7133 if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { 7134 return 7135 } 7136 7137 var data = vnode.data; 7138 var children = vnode.children; 7139 var tag = vnode.tag; 7140 if (isDef(tag)) { 7141 if (false) {} 7142 vnode.elm = vnode.ns 7143 ? nodeOps.createElementNS(vnode.ns, tag) 7144 : nodeOps.createElement(tag, vnode); 7145 setScope(vnode); 7146 7147 /* istanbul ignore if */ 7148 { 7149 createChildren(vnode, children, insertedVnodeQueue); 7150 if (isDef(data)) { 7151 invokeCreateHooks(vnode, insertedVnodeQueue); 7152 } 7153 insert(parentElm, vnode.elm, refElm); 7154 } 7155 7156 if (false) {} 7157 } else if (isTrue(vnode.isComment)) { 7158 vnode.elm = nodeOps.createComment(vnode.text); 7159 insert(parentElm, vnode.elm, refElm); 7160 } else { 7161 vnode.elm = nodeOps.createTextNode(vnode.text); 7162 insert(parentElm, vnode.elm, refElm); 7163 } 7164 } 7165 7166 function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 7167 var i = vnode.data; 7168 if (isDef(i)) { 7169 var isReactivated = isDef(vnode.componentInstance) && i.keepAlive; 7170 if (isDef(i = i.hook) && isDef(i = i.init)) { 7171 i(vnode, false /* hydrating */, parentElm, refElm); 7172 } 7173 // after calling the init hook, if the vnode is a child component 7174 // it should've created a child instance and mounted it. the child 7175 // component also has set the placeholder vnode's elm. 7176 // in that case we can just return the element and be done. 7177 if (isDef(vnode.componentInstance)) { 7178 initComponent(vnode, insertedVnodeQueue); 7179 if (isTrue(isReactivated)) { 7180 reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); 7181 } 7182 return true 7183 } 7184 } 7185 } 7186 7187 function initComponent (vnode, insertedVnodeQueue) { 7188 if (isDef(vnode.data.pendingInsert)) { 7189 insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); 7190 } 7191 vnode.elm = vnode.componentInstance.$el; 7192 if (isPatchable(vnode)) { 7193 invokeCreateHooks(vnode, insertedVnodeQueue); 7194 setScope(vnode); 7195 } else { 7196 // empty component root. 7197 // skip all element-related modules except for ref (#3455) 7198 registerRef(vnode); 7199 // make sure to invoke the insert hook 7200 insertedVnodeQueue.push(vnode); 7201 } 7202 } 7203 7204 function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 7205 var i; 7206 // hack for #4339: a reactivated component with inner transition 7207 // does not trigger because the inner node's created hooks are not called 7208 // again. It's not ideal to involve module-specific logic in here but 7209 // there doesn't seem to be a better way to do it. 7210 var innerNode = vnode; 7211 while (innerNode.componentInstance) { 7212 innerNode = innerNode.componentInstance._vnode; 7213 if (isDef(i = innerNode.data) && isDef(i = i.transition)) { 7214 for (i = 0; i < cbs.activate.length; ++i) { 7215 cbs.activate[i](emptyNode, innerNode); 7216 } 7217 insertedVnodeQueue.push(innerNode); 7218 break 7219 } 7220 } 7221 // unlike a newly created component, 7222 // a reactivated keep-alive component doesn't insert itself 7223 insert(parentElm, vnode.elm, refElm); 7224 } 7225 7226 function insert (parent, elm, ref) { 7227 if (isDef(parent)) { 7228 if (isDef(ref)) { 7229 if (ref.parentNode === parent) { 7230 nodeOps.insertBefore(parent, elm, ref); 7231 } 7232 } else { 7233 nodeOps.appendChild(parent, elm); 7234 } 7235 } 7236 } 7237 7238 function createChildren (vnode, children, insertedVnodeQueue) { 7239 if (Array.isArray(children)) { 7240 for (var i = 0; i < children.length; ++i) { 7241 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true); 7242 } 7243 } else if (isPrimitive(vnode.text)) { 7244 nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text)); 7245 } 7246 } 7247 7248 function isPatchable (vnode) { 7249 while (vnode.componentInstance) { 7250 vnode = vnode.componentInstance._vnode; 7251 } 7252 return isDef(vnode.tag) 7253 } 7254 7255 function invokeCreateHooks (vnode, insertedVnodeQueue) { 7256 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 7257 cbs.create[i$1](emptyNode, vnode); 7258 } 7259 i = vnode.data.hook; // Reuse variable 7260 if (isDef(i)) { 7261 if (isDef(i.create)) { i.create(emptyNode, vnode); } 7262 if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); } 7263 } 7264 } 7265 7266 // set scope id attribute for scoped CSS. 7267 // this is implemented as a special case to avoid the overhead 7268 // of going through the normal attribute patching process. 7269 function setScope (vnode) { 7270 var i; 7271 var ancestor = vnode; 7272 while (ancestor) { 7273 if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) { 7274 nodeOps.setAttribute(vnode.elm, i, ''); 7275 } 7276 ancestor = ancestor.parent; 7277 } 7278 // for slot content they should also get the scopeId from the host instance. 7279 if (isDef(i = activeInstance) && 7280 i !== vnode.context && 7281 isDef(i = i.$options._scopeId) 7282 ) { 7283 nodeOps.setAttribute(vnode.elm, i, ''); 7284 } 7285 } 7286 7287 function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { 7288 for (; startIdx <= endIdx; ++startIdx) { 7289 createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm); 7290 } 7291 } 7292 7293 function invokeDestroyHook (vnode) { 7294 var i, j; 7295 var data = vnode.data; 7296 if (isDef(data)) { 7297 if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); } 7298 for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); } 7299 } 7300 if (isDef(i = vnode.children)) { 7301 for (j = 0; j < vnode.children.length; ++j) { 7302 invokeDestroyHook(vnode.children[j]); 7303 } 7304 } 7305 } 7306 7307 function removeVnodes (parentElm, vnodes, startIdx, endIdx) { 7308 for (; startIdx <= endIdx; ++startIdx) { 7309 var ch = vnodes[startIdx]; 7310 if (isDef(ch)) { 7311 if (isDef(ch.tag)) { 7312 removeAndInvokeRemoveHook(ch); 7313 invokeDestroyHook(ch); 7314 } else { // Text node 7315 removeNode(ch.elm); 7316 } 7317 } 7318 } 7319 } 7320 7321 function removeAndInvokeRemoveHook (vnode, rm) { 7322 if (isDef(rm) || isDef(vnode.data)) { 7323 var i; 7324 var listeners = cbs.remove.length + 1; 7325 if (isDef(rm)) { 7326 // we have a recursively passed down rm callback 7327 // increase the listeners count 7328 rm.listeners += listeners; 7329 } else { 7330 // directly removing 7331 rm = createRmCb(vnode.elm, listeners); 7332 } 7333 // recursively invoke hooks on child component root node 7334 if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) { 7335 removeAndInvokeRemoveHook(i, rm); 7336 } 7337 for (i = 0; i < cbs.remove.length; ++i) { 7338 cbs.remove[i](vnode, rm); 7339 } 7340 if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) { 7341 i(vnode, rm); 7342 } else { 7343 rm(); 7344 } 7345 } else { 7346 removeNode(vnode.elm); 7347 } 7348 } 7349 7350 function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { 7351 var oldStartIdx = 0; 7352 var newStartIdx = 0; 7353 var oldEndIdx = oldCh.length - 1; 7354 var oldStartVnode = oldCh[0]; 7355 var oldEndVnode = oldCh[oldEndIdx]; 7356 var newEndIdx = newCh.length - 1; 7357 var newStartVnode = newCh[0]; 7358 var newEndVnode = newCh[newEndIdx]; 7359 var oldKeyToIdx, idxInOld, elmToMove, refElm; 7360 7361 // removeOnly is a special flag used only by <transition-group> 7362 // to ensure removed elements stay in correct relative positions 7363 // during leaving transitions 7364 var canMove = !removeOnly; 7365 7366 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { 7367 if (isUndef(oldStartVnode)) { 7368 oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left 7369 } else if (isUndef(oldEndVnode)) { 7370 oldEndVnode = oldCh[--oldEndIdx]; 7371 } else if (sameVnode(oldStartVnode, newStartVnode)) { 7372 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue); 7373 oldStartVnode = oldCh[++oldStartIdx]; 7374 newStartVnode = newCh[++newStartIdx]; 7375 } else if (sameVnode(oldEndVnode, newEndVnode)) { 7376 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue); 7377 oldEndVnode = oldCh[--oldEndIdx]; 7378 newEndVnode = newCh[--newEndIdx]; 7379 } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right 7380 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); 7381 canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); 7382 oldStartVnode = oldCh[++oldStartIdx]; 7383 newEndVnode = newCh[--newEndIdx]; 7384 } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left 7385 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); 7386 canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); 7387 oldEndVnode = oldCh[--oldEndIdx]; 7388 newStartVnode = newCh[++newStartIdx]; 7389 } else { 7390 if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); } 7391 idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : null; 7392 if (isUndef(idxInOld)) { // New element 7393 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 7394 newStartVnode = newCh[++newStartIdx]; 7395 } else { 7396 elmToMove = oldCh[idxInOld]; 7397 /* istanbul ignore if */ 7398 if (false) {} 7399 if (sameVnode(elmToMove, newStartVnode)) { 7400 patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); 7401 oldCh[idxInOld] = undefined; 7402 canMove && nodeOps.insertBefore(parentElm, newStartVnode.elm, oldStartVnode.elm); 7403 newStartVnode = newCh[++newStartIdx]; 7404 } else { 7405 // same key but different element. treat as new element 7406 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 7407 newStartVnode = newCh[++newStartIdx]; 7408 } 7409 } 7410 } 7411 } 7412 if (oldStartIdx > oldEndIdx) { 7413 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; 7414 addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); 7415 } else if (newStartIdx > newEndIdx) { 7416 removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); 7417 } 7418 } 7419 7420 function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) { 7421 if (oldVnode === vnode) { 7422 return 7423 } 7424 // reuse element for static trees. 7425 // note we only do this if the vnode is cloned - 7426 // if the new node is not cloned it means the render functions have been 7427 // reset by the hot-reload-api and we need to do a proper re-render. 7428 if (isTrue(vnode.isStatic) && 7429 isTrue(oldVnode.isStatic) && 7430 vnode.key === oldVnode.key && 7431 (isTrue(vnode.isCloned) || isTrue(vnode.isOnce)) 7432 ) { 7433 vnode.elm = oldVnode.elm; 7434 vnode.componentInstance = oldVnode.componentInstance; 7435 return 7436 } 7437 var i; 7438 var data = vnode.data; 7439 if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) { 7440 i(oldVnode, vnode); 7441 } 7442 var elm = vnode.elm = oldVnode.elm; 7443 var oldCh = oldVnode.children; 7444 var ch = vnode.children; 7445 if (isDef(data) && isPatchable(vnode)) { 7446 for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); } 7447 if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); } 7448 } 7449 if (isUndef(vnode.text)) { 7450 if (isDef(oldCh) && isDef(ch)) { 7451 if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); } 7452 } else if (isDef(ch)) { 7453 if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); } 7454 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); 7455 } else if (isDef(oldCh)) { 7456 removeVnodes(elm, oldCh, 0, oldCh.length - 1); 7457 } else if (isDef(oldVnode.text)) { 7458 nodeOps.setTextContent(elm, ''); 7459 } 7460 } else if (oldVnode.text !== vnode.text) { 7461 nodeOps.setTextContent(elm, vnode.text); 7462 } 7463 if (isDef(data)) { 7464 if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); } 7465 } 7466 } 7467 7468 function invokeInsertHook (vnode, queue, initial) { 7469 // delay insert hooks for component root nodes, invoke them after the 7470 // element is really inserted 7471 if (isTrue(initial) && isDef(vnode.parent)) { 7472 vnode.parent.data.pendingInsert = queue; 7473 } else { 7474 for (var i = 0; i < queue.length; ++i) { 7475 queue[i].data.hook.insert(queue[i]); 7476 } 7477 } 7478 } 7479 7480 var bailed = false; 7481 // list of modules that can skip create hook during hydration because they 7482 // are already rendered on the client or has no need for initialization 7483 var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key'); 7484 7485 // Note: this is a browser-only function so we can assume elms are DOM nodes. 7486 function hydrate (elm, vnode, insertedVnodeQueue) { 7487 if (false) {} 7488 vnode.elm = elm; 7489 var tag = vnode.tag; 7490 var data = vnode.data; 7491 var children = vnode.children; 7492 if (isDef(data)) { 7493 if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); } 7494 if (isDef(i = vnode.componentInstance)) { 7495 // child component. it should have hydrated its own tree. 7496 initComponent(vnode, insertedVnodeQueue); 7497 return true 7498 } 7499 } 7500 if (isDef(tag)) { 7501 if (isDef(children)) { 7502 // empty element, allow client to pick up and populate children 7503 if (!elm.hasChildNodes()) { 7504 createChildren(vnode, children, insertedVnodeQueue); 7505 } else { 7506 var childrenMatch = true; 7507 var childNode = elm.firstChild; 7508 for (var i$1 = 0; i$1 < children.length; i$1++) { 7509 if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) { 7510 childrenMatch = false; 7511 break 7512 } 7513 childNode = childNode.nextSibling; 7514 } 7515 // if childNode is not null, it means the actual childNodes list is 7516 // longer than the virtual children list. 7517 if (!childrenMatch || childNode) { 7518 if (false 7519 ) {} 7520 return false 7521 } 7522 } 7523 } 7524 if (isDef(data)) { 7525 for (var key in data) { 7526 if (!isRenderedModule(key)) { 7527 invokeCreateHooks(vnode, insertedVnodeQueue); 7528 break 7529 } 7530 } 7531 } 7532 } else if (elm.data !== vnode.text) { 7533 elm.data = vnode.text; 7534 } 7535 return true 7536 } 7537 7538 function assertNodeMatch (node, vnode) { 7539 if (isDef(vnode.tag)) { 7540 return ( 7541 vnode.tag.indexOf('vue-component') === 0 || 7542 vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()) 7543 ) 7544 } else { 7545 return node.nodeType === (vnode.isComment ? 8 : 3) 7546 } 7547 } 7548 7549 return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) { 7550 if (isUndef(vnode)) { 7551 if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); } 7552 return 7553 } 7554 7555 var isInitialPatch = false; 7556 var insertedVnodeQueue = []; 7557 7558 if (isUndef(oldVnode)) { 7559 // empty mount (likely as component), create new root element 7560 isInitialPatch = true; 7561 createElm(vnode, insertedVnodeQueue, parentElm, refElm); 7562 } else { 7563 var isRealElement = isDef(oldVnode.nodeType); 7564 if (!isRealElement && sameVnode(oldVnode, vnode)) { 7565 // patch existing root node 7566 patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly); 7567 } else { 7568 if (isRealElement) { 7569 // mounting to a real element 7570 // check if this is server-rendered content and if we can perform 7571 // a successful hydration. 7572 if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { 7573 oldVnode.removeAttribute(SSR_ATTR); 7574 hydrating = true; 7575 } 7576 if (isTrue(hydrating)) { 7577 if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { 7578 invokeInsertHook(vnode, insertedVnodeQueue, true); 7579 return oldVnode 7580 } else if (false) {} 7581 } 7582 // either not server-rendered, or hydration failed. 7583 // create an empty node and replace it 7584 oldVnode = emptyNodeAt(oldVnode); 7585 } 7586 // replacing existing element 7587 var oldElm = oldVnode.elm; 7588 var parentElm$1 = nodeOps.parentNode(oldElm); 7589 createElm( 7590 vnode, 7591 insertedVnodeQueue, 7592 // extremely rare edge case: do not insert if old element is in a 7593 // leaving transition. Only happens when combining transition + 7594 // keep-alive + HOCs. (#4590) 7595 oldElm._leaveCb ? null : parentElm$1, 7596 nodeOps.nextSibling(oldElm) 7597 ); 7598 7599 if (isDef(vnode.parent)) { 7600 // component root element replaced. 7601 // update parent placeholder node element, recursively 7602 var ancestor = vnode.parent; 7603 while (ancestor) { 7604 ancestor.elm = vnode.elm; 7605 ancestor = ancestor.parent; 7606 } 7607 if (isPatchable(vnode)) { 7608 for (var i = 0; i < cbs.create.length; ++i) { 7609 cbs.create[i](emptyNode, vnode.parent); 7610 } 7611 } 7612 } 7613 7614 if (isDef(parentElm$1)) { 7615 removeVnodes(parentElm$1, [oldVnode], 0, 0); 7616 } else if (isDef(oldVnode.tag)) { 7617 invokeDestroyHook(oldVnode); 7618 } 7619 } 7620 } 7621 7622 invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); 7623 return vnode.elm 7624 } 7625 } 7626 7627 /* */ 7628 7629 var directives = { 7630 create: updateDirectives, 7631 update: updateDirectives, 7632 destroy: function unbindDirectives (vnode) { 7633 updateDirectives(vnode, emptyNode); 7634 } 7635 }; 7636 7637 function updateDirectives (oldVnode, vnode) { 7638 if (oldVnode.data.directives || vnode.data.directives) { 7639 _update(oldVnode, vnode); 7640 } 7641 } 7642 7643 function _update (oldVnode, vnode) { 7644 var isCreate = oldVnode === emptyNode; 7645 var isDestroy = vnode === emptyNode; 7646 var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); 7647 var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); 7648 7649 var dirsWithInsert = []; 7650 var dirsWithPostpatch = []; 7651 7652 var key, oldDir, dir; 7653 for (key in newDirs) { 7654 oldDir = oldDirs[key]; 7655 dir = newDirs[key]; 7656 if (!oldDir) { 7657 // new directive, bind 7658 callHook$1(dir, 'bind', vnode, oldVnode); 7659 if (dir.def && dir.def.inserted) { 7660 dirsWithInsert.push(dir); 7661 } 7662 } else { 7663 // existing directive, update 7664 dir.oldValue = oldDir.value; 7665 callHook$1(dir, 'update', vnode, oldVnode); 7666 if (dir.def && dir.def.componentUpdated) { 7667 dirsWithPostpatch.push(dir); 7668 } 7669 } 7670 } 7671 7672 if (dirsWithInsert.length) { 7673 var callInsert = function () { 7674 for (var i = 0; i < dirsWithInsert.length; i++) { 7675 callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); 7676 } 7677 }; 7678 if (isCreate) { 7679 mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert); 7680 } else { 7681 callInsert(); 7682 } 7683 } 7684 7685 if (dirsWithPostpatch.length) { 7686 mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () { 7687 for (var i = 0; i < dirsWithPostpatch.length; i++) { 7688 callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); 7689 } 7690 }); 7691 } 7692 7693 if (!isCreate) { 7694 for (key in oldDirs) { 7695 if (!newDirs[key]) { 7696 // no longer present, unbind 7697 callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); 7698 } 7699 } 7700 } 7701 } 7702 7703 var emptyModifiers = Object.create(null); 7704 7705 function normalizeDirectives$1 ( 7706 dirs, 7707 vm 7708 ) { 7709 var res = Object.create(null); 7710 if (!dirs) { 7711 return res 7712 } 7713 var i, dir; 7714 for (i = 0; i < dirs.length; i++) { 7715 dir = dirs[i]; 7716 if (!dir.modifiers) { 7717 dir.modifiers = emptyModifiers; 7718 } 7719 res[getRawDirName(dir)] = dir; 7720 dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); 7721 } 7722 return res 7723 } 7724 7725 function getRawDirName (dir) { 7726 return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) 7727 } 7728 7729 function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { 7730 var fn = dir.def && dir.def[hook]; 7731 if (fn) { 7732 try { 7733 fn(vnode.elm, dir, vnode, oldVnode, isDestroy); 7734 } catch (e) { 7735 handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook")); 7736 } 7737 } 7738 } 7739 7740 var baseModules = [ 7741 ref, 7742 directives 7743 ]; 7744 7745 /* */ 7746 7747 function updateAttrs (oldVnode, vnode) { 7748 if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { 7749 return 7750 } 7751 var key, cur, old; 7752 var elm = vnode.elm; 7753 var oldAttrs = oldVnode.data.attrs || {}; 7754 var attrs = vnode.data.attrs || {}; 7755 // clone observed objects, as the user probably wants to mutate it 7756 if (isDef(attrs.__ob__)) { 7757 attrs = vnode.data.attrs = extend({}, attrs); 7758 } 7759 7760 for (key in attrs) { 7761 cur = attrs[key]; 7762 old = oldAttrs[key]; 7763 if (old !== cur) { 7764 setAttr(elm, key, cur); 7765 } 7766 } 7767 // #4391: in IE9, setting type can reset value for input[type=radio] 7768 /* istanbul ignore if */ 7769 if (isIE9 && attrs.value !== oldAttrs.value) { 7770 setAttr(elm, 'value', attrs.value); 7771 } 7772 for (key in oldAttrs) { 7773 if (isUndef(attrs[key])) { 7774 if (isXlink(key)) { 7775 elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); 7776 } else if (!isEnumeratedAttr(key)) { 7777 elm.removeAttribute(key); 7778 } 7779 } 7780 } 7781 } 7782 7783 function setAttr (el, key, value) { 7784 if (isBooleanAttr(key)) { 7785 // set attribute for blank value 7786 // e.g. <option disabled>Select one</option> 7787 if (isFalsyAttrValue(value)) { 7788 el.removeAttribute(key); 7789 } else { 7790 el.setAttribute(key, key); 7791 } 7792 } else if (isEnumeratedAttr(key)) { 7793 el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); 7794 } else if (isXlink(key)) { 7795 if (isFalsyAttrValue(value)) { 7796 el.removeAttributeNS(xlinkNS, getXlinkProp(key)); 7797 } else { 7798 el.setAttributeNS(xlinkNS, key, value); 7799 } 7800 } else { 7801 if (isFalsyAttrValue(value)) { 7802 el.removeAttribute(key); 7803 } else { 7804 el.setAttribute(key, value); 7805 } 7806 } 7807 } 7808 7809 var attrs = { 7810 create: updateAttrs, 7811 update: updateAttrs 7812 }; 7813 7814 /* */ 7815 7816 function updateClass (oldVnode, vnode) { 7817 var el = vnode.elm; 7818 var data = vnode.data; 7819 var oldData = oldVnode.data; 7820 if ( 7821 isUndef(data.staticClass) && 7822 isUndef(data.class) && ( 7823 isUndef(oldData) || ( 7824 isUndef(oldData.staticClass) && 7825 isUndef(oldData.class) 7826 ) 7827 ) 7828 ) { 7829 return 7830 } 7831 7832 var cls = genClassForVnode(vnode); 7833 7834 // handle transition classes 7835 var transitionClass = el._transitionClasses; 7836 if (isDef(transitionClass)) { 7837 cls = concat(cls, stringifyClass(transitionClass)); 7838 } 7839 7840 // set the class 7841 if (cls !== el._prevClass) { 7842 el.setAttribute('class', cls); 7843 el._prevClass = cls; 7844 } 7845 } 7846 7847 var klass = { 7848 create: updateClass, 7849 update: updateClass 7850 }; 7851 7852 /* */ 7853 7854 // in some cases, the event used has to be determined at runtime 7855 // so we used some reserved tokens during compile. 7856 var RANGE_TOKEN = '__r'; 7857 var CHECKBOX_RADIO_TOKEN = '__c'; 7858 7859 /* */ 7860 7861 // normalize v-model event tokens that can only be determined at runtime. 7862 // it's important to place the event as the first in the array because 7863 // the whole point is ensuring the v-model callback gets called before 7864 // user-attached handlers. 7865 function normalizeEvents (on) { 7866 var event; 7867 /* istanbul ignore if */ 7868 if (isDef(on[RANGE_TOKEN])) { 7869 // IE input[type=range] only supports `change` event 7870 event = isIE ? 'change' : 'input'; 7871 on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); 7872 delete on[RANGE_TOKEN]; 7873 } 7874 if (isDef(on[CHECKBOX_RADIO_TOKEN])) { 7875 // Chrome fires microtasks in between click/change, leads to #4521 7876 event = isChrome ? 'click' : 'change'; 7877 on[event] = [].concat(on[CHECKBOX_RADIO_TOKEN], on[event] || []); 7878 delete on[CHECKBOX_RADIO_TOKEN]; 7879 } 7880 } 7881 7882 var target$1; 7883 7884 function add$1 ( 7885 event, 7886 handler, 7887 once$$1, 7888 capture, 7889 passive 7890 ) { 7891 if (once$$1) { 7892 var oldHandler = handler; 7893 var _target = target$1; // save current target element in closure 7894 handler = function (ev) { 7895 var res = arguments.length === 1 7896 ? oldHandler(ev) 7897 : oldHandler.apply(null, arguments); 7898 if (res !== null) { 7899 remove$2(event, handler, capture, _target); 7900 } 7901 }; 7902 } 7903 target$1.addEventListener( 7904 event, 7905 handler, 7906 supportsPassive 7907 ? { capture: capture, passive: passive } 7908 : capture 7909 ); 7910 } 7911 7912 function remove$2 ( 7913 event, 7914 handler, 7915 capture, 7916 _target 7917 ) { 7918 (_target || target$1).removeEventListener(event, handler, capture); 7919 } 7920 7921 function updateDOMListeners (oldVnode, vnode) { 7922 if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { 7923 return 7924 } 7925 var on = vnode.data.on || {}; 7926 var oldOn = oldVnode.data.on || {}; 7927 target$1 = vnode.elm; 7928 normalizeEvents(on); 7929 updateListeners(on, oldOn, add$1, remove$2, vnode.context); 7930 } 7931 7932 var events = { 7933 create: updateDOMListeners, 7934 update: updateDOMListeners 7935 }; 7936 7937 /* */ 7938 7939 function updateDOMProps (oldVnode, vnode) { 7940 if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { 7941 return 7942 } 7943 var key, cur; 7944 var elm = vnode.elm; 7945 var oldProps = oldVnode.data.domProps || {}; 7946 var props = vnode.data.domProps || {}; 7947 // clone observed objects, as the user probably wants to mutate it 7948 if (isDef(props.__ob__)) { 7949 props = vnode.data.domProps = extend({}, props); 7950 } 7951 7952 for (key in oldProps) { 7953 if (isUndef(props[key])) { 7954 elm[key] = ''; 7955 } 7956 } 7957 for (key in props) { 7958 cur = props[key]; 7959 // ignore children if the node has textContent or innerHTML, 7960 // as these will throw away existing DOM nodes and cause removal errors 7961 // on subsequent patches (#3360) 7962 if (key === 'textContent' || key === 'innerHTML') { 7963 if (vnode.children) { vnode.children.length = 0; } 7964 if (cur === oldProps[key]) { continue } 7965 } 7966 7967 if (key === 'value') { 7968 // store value as _value as well since 7969 // non-string values will be stringified 7970 elm._value = cur; 7971 // avoid resetting cursor position when value is the same 7972 var strCur = isUndef(cur) ? '' : String(cur); 7973 if (shouldUpdateValue(elm, vnode, strCur)) { 7974 elm.value = strCur; 7975 } 7976 } else { 7977 elm[key] = cur; 7978 } 7979 } 7980 } 7981 7982 // check platforms/web/util/attrs.js acceptValue 7983 7984 7985 function shouldUpdateValue ( 7986 elm, 7987 vnode, 7988 checkVal 7989 ) { 7990 return (!elm.composing && ( 7991 vnode.tag === 'option' || 7992 isDirty(elm, checkVal) || 7993 isInputChanged(elm, checkVal) 7994 )) 7995 } 7996 7997 function isDirty (elm, checkVal) { 7998 // return true when textbox (.number and .trim) loses focus and its value is not equal to the updated value 7999 return document.activeElement !== elm && elm.value !== checkVal 8000 } 8001 8002 function isInputChanged (elm, newVal) { 8003 var value = elm.value; 8004 var modifiers = elm._vModifiers; // injected by v-model runtime 8005 if ((isDef(modifiers) && modifiers.number) || elm.type === 'number') { 8006 return toNumber(value) !== toNumber(newVal) 8007 } 8008 if (isDef(modifiers) && modifiers.trim) { 8009 return value.trim() !== newVal.trim() 8010 } 8011 return value !== newVal 8012 } 8013 8014 var domProps = { 8015 create: updateDOMProps, 8016 update: updateDOMProps 8017 }; 8018 8019 /* */ 8020 8021 var parseStyleText = cached(function (cssText) { 8022 var res = {}; 8023 var listDelimiter = /;(?![^(]*\))/g; 8024 var propertyDelimiter = /:(.+)/; 8025 cssText.split(listDelimiter).forEach(function (item) { 8026 if (item) { 8027 var tmp = item.split(propertyDelimiter); 8028 tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); 8029 } 8030 }); 8031 return res 8032 }); 8033 8034 // merge static and dynamic style data on the same vnode 8035 function normalizeStyleData (data) { 8036 var style = normalizeStyleBinding(data.style); 8037 // static style is pre-processed into an object during compilation 8038 // and is always a fresh object, so it's safe to merge into it 8039 return data.staticStyle 8040 ? extend(data.staticStyle, style) 8041 : style 8042 } 8043 8044 // normalize possible array / string values into Object 8045 function normalizeStyleBinding (bindingStyle) { 8046 if (Array.isArray(bindingStyle)) { 8047 return toObject(bindingStyle) 8048 } 8049 if (typeof bindingStyle === 'string') { 8050 return parseStyleText(bindingStyle) 8051 } 8052 return bindingStyle 8053 } 8054 8055 /** 8056 * parent component style should be after child's 8057 * so that parent component's style could override it 8058 */ 8059 function getStyle (vnode, checkChild) { 8060 var res = {}; 8061 var styleData; 8062 8063 if (checkChild) { 8064 var childNode = vnode; 8065 while (childNode.componentInstance) { 8066 childNode = childNode.componentInstance._vnode; 8067 if (childNode.data && (styleData = normalizeStyleData(childNode.data))) { 8068 extend(res, styleData); 8069 } 8070 } 8071 } 8072 8073 if ((styleData = normalizeStyleData(vnode.data))) { 8074 extend(res, styleData); 8075 } 8076 8077 var parentNode = vnode; 8078 while ((parentNode = parentNode.parent)) { 8079 if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { 8080 extend(res, styleData); 8081 } 8082 } 8083 return res 8084 } 8085 8086 /* */ 8087 8088 var cssVarRE = /^--/; 8089 var importantRE = /\s*!important$/; 8090 var setProp = function (el, name, val) { 8091 /* istanbul ignore if */ 8092 if (cssVarRE.test(name)) { 8093 el.style.setProperty(name, val); 8094 } else if (importantRE.test(val)) { 8095 el.style.setProperty(name, val.replace(importantRE, ''), 'important'); 8096 } else { 8097 var normalizedName = normalize(name); 8098 if (Array.isArray(val)) { 8099 // Support values array created by autoprefixer, e.g. 8100 // {display: ["-webkit-box", "-ms-flexbox", "flex"]} 8101 // Set them one by one, and the browser will only set those it can recognize 8102 for (var i = 0, len = val.length; i < len; i++) { 8103 el.style[normalizedName] = val[i]; 8104 } 8105 } else { 8106 el.style[normalizedName] = val; 8107 } 8108 } 8109 }; 8110 8111 var prefixes = ['Webkit', 'Moz', 'ms']; 8112 8113 var testEl; 8114 var normalize = cached(function (prop) { 8115 testEl = testEl || document.createElement('div'); 8116 prop = camelize(prop); 8117 if (prop !== 'filter' && (prop in testEl.style)) { 8118 return prop 8119 } 8120 var upper = prop.charAt(0).toUpperCase() + prop.slice(1); 8121 for (var i = 0; i < prefixes.length; i++) { 8122 var prefixed = prefixes[i] + upper; 8123 if (prefixed in testEl.style) { 8124 return prefixed 8125 } 8126 } 8127 }); 8128 8129 function updateStyle (oldVnode, vnode) { 8130 var data = vnode.data; 8131 var oldData = oldVnode.data; 8132 8133 if (isUndef(data.staticStyle) && isUndef(data.style) && 8134 isUndef(oldData.staticStyle) && isUndef(oldData.style) 8135 ) { 8136 return 8137 } 8138 8139 var cur, name; 8140 var el = vnode.elm; 8141 var oldStaticStyle = oldData.staticStyle; 8142 var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; 8143 8144 // if static style exists, stylebinding already merged into it when doing normalizeStyleData 8145 var oldStyle = oldStaticStyle || oldStyleBinding; 8146 8147 var style = normalizeStyleBinding(vnode.data.style) || {}; 8148 8149 // store normalized style under a different key for next diff 8150 // make sure to clone it if it's reactive, since the user likley wants 8151 // to mutate it. 8152 vnode.data.normalizedStyle = isDef(style.__ob__) 8153 ? extend({}, style) 8154 : style; 8155 8156 var newStyle = getStyle(vnode, true); 8157 8158 for (name in oldStyle) { 8159 if (isUndef(newStyle[name])) { 8160 setProp(el, name, ''); 8161 } 8162 } 8163 for (name in newStyle) { 8164 cur = newStyle[name]; 8165 if (cur !== oldStyle[name]) { 8166 // ie9 setting to null has no effect, must use empty string 8167 setProp(el, name, cur == null ? '' : cur); 8168 } 8169 } 8170 } 8171 8172 var style = { 8173 create: updateStyle, 8174 update: updateStyle 8175 }; 8176 8177 /* */ 8178 8179 /** 8180 * Add class with compatibility for SVG since classList is not supported on 8181 * SVG elements in IE 8182 */ 8183 function addClass (el, cls) { 8184 /* istanbul ignore if */ 8185 if (!cls || !(cls = cls.trim())) { 8186 return 8187 } 8188 8189 /* istanbul ignore else */ 8190 if (el.classList) { 8191 if (cls.indexOf(' ') > -1) { 8192 cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); }); 8193 } else { 8194 el.classList.add(cls); 8195 } 8196 } else { 8197 var cur = " " + (el.getAttribute('class') || '') + " "; 8198 if (cur.indexOf(' ' + cls + ' ') < 0) { 8199 el.setAttribute('class', (cur + cls).trim()); 8200 } 8201 } 8202 } 8203 8204 /** 8205 * Remove class with compatibility for SVG since classList is not supported on 8206 * SVG elements in IE 8207 */ 8208 function removeClass (el, cls) { 8209 /* istanbul ignore if */ 8210 if (!cls || !(cls = cls.trim())) { 8211 return 8212 } 8213 8214 /* istanbul ignore else */ 8215 if (el.classList) { 8216 if (cls.indexOf(' ') > -1) { 8217 cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); }); 8218 } else { 8219 el.classList.remove(cls); 8220 } 8221 } else { 8222 var cur = " " + (el.getAttribute('class') || '') + " "; 8223 var tar = ' ' + cls + ' '; 8224 while (cur.indexOf(tar) >= 0) { 8225 cur = cur.replace(tar, ' '); 8226 } 8227 el.setAttribute('class', cur.trim()); 8228 } 8229 } 8230 8231 /* */ 8232 8233 function resolveTransition (def$$1) { 8234 if (!def$$1) { 8235 return 8236 } 8237 /* istanbul ignore else */ 8238 if (typeof def$$1 === 'object') { 8239 var res = {}; 8240 if (def$$1.css !== false) { 8241 extend(res, autoCssTransition(def$$1.name || 'v')); 8242 } 8243 extend(res, def$$1); 8244 return res 8245 } else if (typeof def$$1 === 'string') { 8246 return autoCssTransition(def$$1) 8247 } 8248 } 8249 8250 var autoCssTransition = cached(function (name) { 8251 return { 8252 enterClass: (name + "-enter"), 8253 enterToClass: (name + "-enter-to"), 8254 enterActiveClass: (name + "-enter-active"), 8255 leaveClass: (name + "-leave"), 8256 leaveToClass: (name + "-leave-to"), 8257 leaveActiveClass: (name + "-leave-active") 8258 } 8259 }); 8260 8261 var hasTransition = inBrowser && !isIE9; 8262 var TRANSITION = 'transition'; 8263 var ANIMATION = 'animation'; 8264 8265 // Transition property/event sniffing 8266 var transitionProp = 'transition'; 8267 var transitionEndEvent = 'transitionend'; 8268 var animationProp = 'animation'; 8269 var animationEndEvent = 'animationend'; 8270 if (hasTransition) { 8271 /* istanbul ignore if */ 8272 if (window.ontransitionend === undefined && 8273 window.onwebkittransitionend !== undefined 8274 ) { 8275 transitionProp = 'WebkitTransition'; 8276 transitionEndEvent = 'webkitTransitionEnd'; 8277 } 8278 if (window.onanimationend === undefined && 8279 window.onwebkitanimationend !== undefined 8280 ) { 8281 animationProp = 'WebkitAnimation'; 8282 animationEndEvent = 'webkitAnimationEnd'; 8283 } 8284 } 8285 8286 // binding to window is necessary to make hot reload work in IE in strict mode 8287 var raf = inBrowser && window.requestAnimationFrame 8288 ? window.requestAnimationFrame.bind(window) 8289 : setTimeout; 8290 8291 function nextFrame (fn) { 8292 raf(function () { 8293 raf(fn); 8294 }); 8295 } 8296 8297 function addTransitionClass (el, cls) { 8298 (el._transitionClasses || (el._transitionClasses = [])).push(cls); 8299 addClass(el, cls); 8300 } 8301 8302 function removeTransitionClass (el, cls) { 8303 if (el._transitionClasses) { 8304 remove(el._transitionClasses, cls); 8305 } 8306 removeClass(el, cls); 8307 } 8308 8309 function whenTransitionEnds ( 8310 el, 8311 expectedType, 8312 cb 8313 ) { 8314 var ref = getTransitionInfo(el, expectedType); 8315 var type = ref.type; 8316 var timeout = ref.timeout; 8317 var propCount = ref.propCount; 8318 if (!type) { return cb() } 8319 var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; 8320 var ended = 0; 8321 var end = function () { 8322 el.removeEventListener(event, onEnd); 8323 cb(); 8324 }; 8325 var onEnd = function (e) { 8326 if (e.target === el) { 8327 if (++ended >= propCount) { 8328 end(); 8329 } 8330 } 8331 }; 8332 setTimeout(function () { 8333 if (ended < propCount) { 8334 end(); 8335 } 8336 }, timeout + 1); 8337 el.addEventListener(event, onEnd); 8338 } 8339 8340 var transformRE = /\b(transform|all)(,|$)/; 8341 8342 function getTransitionInfo (el, expectedType) { 8343 var styles = window.getComputedStyle(el); 8344 var transitionDelays = styles[transitionProp + 'Delay'].split(', '); 8345 var transitionDurations = styles[transitionProp + 'Duration'].split(', '); 8346 var transitionTimeout = getTimeout(transitionDelays, transitionDurations); 8347 var animationDelays = styles[animationProp + 'Delay'].split(', '); 8348 var animationDurations = styles[animationProp + 'Duration'].split(', '); 8349 var animationTimeout = getTimeout(animationDelays, animationDurations); 8350 8351 var type; 8352 var timeout = 0; 8353 var propCount = 0; 8354 /* istanbul ignore if */ 8355 if (expectedType === TRANSITION) { 8356 if (transitionTimeout > 0) { 8357 type = TRANSITION; 8358 timeout = transitionTimeout; 8359 propCount = transitionDurations.length; 8360 } 8361 } else if (expectedType === ANIMATION) { 8362 if (animationTimeout > 0) { 8363 type = ANIMATION; 8364 timeout = animationTimeout; 8365 propCount = animationDurations.length; 8366 } 8367 } else { 8368 timeout = Math.max(transitionTimeout, animationTimeout); 8369 type = timeout > 0 8370 ? transitionTimeout > animationTimeout 8371 ? TRANSITION 8372 : ANIMATION 8373 : null; 8374 propCount = type 8375 ? type === TRANSITION 8376 ? transitionDurations.length 8377 : animationDurations.length 8378 : 0; 8379 } 8380 var hasTransform = 8381 type === TRANSITION && 8382 transformRE.test(styles[transitionProp + 'Property']); 8383 return { 8384 type: type, 8385 timeout: timeout, 8386 propCount: propCount, 8387 hasTransform: hasTransform 8388 } 8389 } 8390 8391 function getTimeout (delays, durations) { 8392 /* istanbul ignore next */ 8393 while (delays.length < durations.length) { 8394 delays = delays.concat(delays); 8395 } 8396 8397 return Math.max.apply(null, durations.map(function (d, i) { 8398 return toMs(d) + toMs(delays[i]) 8399 })) 8400 } 8401 8402 function toMs (s) { 8403 return Number(s.slice(0, -1)) * 1000 8404 } 8405 8406 /* */ 8407 8408 function enter (vnode, toggleDisplay) { 8409 var el = vnode.elm; 8410 8411 // call leave callback now 8412 if (isDef(el._leaveCb)) { 8413 el._leaveCb.cancelled = true; 8414 el._leaveCb(); 8415 } 8416 8417 var data = resolveTransition(vnode.data.transition); 8418 if (isUndef(data)) { 8419 return 8420 } 8421 8422 /* istanbul ignore if */ 8423 if (isDef(el._enterCb) || el.nodeType !== 1) { 8424 return 8425 } 8426 8427 var css = data.css; 8428 var type = data.type; 8429 var enterClass = data.enterClass; 8430 var enterToClass = data.enterToClass; 8431 var enterActiveClass = data.enterActiveClass; 8432 var appearClass = data.appearClass; 8433 var appearToClass = data.appearToClass; 8434 var appearActiveClass = data.appearActiveClass; 8435 var beforeEnter = data.beforeEnter; 8436 var enter = data.enter; 8437 var afterEnter = data.afterEnter; 8438 var enterCancelled = data.enterCancelled; 8439 var beforeAppear = data.beforeAppear; 8440 var appear = data.appear; 8441 var afterAppear = data.afterAppear; 8442 var appearCancelled = data.appearCancelled; 8443 var duration = data.duration; 8444 8445 // activeInstance will always be the <transition> component managing this 8446 // transition. One edge case to check is when the <transition> is placed 8447 // as the root node of a child component. In that case we need to check 8448 // <transition>'s parent for appear check. 8449 var context = activeInstance; 8450 var transitionNode = activeInstance.$vnode; 8451 while (transitionNode && transitionNode.parent) { 8452 transitionNode = transitionNode.parent; 8453 context = transitionNode.context; 8454 } 8455 8456 var isAppear = !context._isMounted || !vnode.isRootInsert; 8457 8458 if (isAppear && !appear && appear !== '') { 8459 return 8460 } 8461 8462 var startClass = isAppear && appearClass 8463 ? appearClass 8464 : enterClass; 8465 var activeClass = isAppear && appearActiveClass 8466 ? appearActiveClass 8467 : enterActiveClass; 8468 var toClass = isAppear && appearToClass 8469 ? appearToClass 8470 : enterToClass; 8471 8472 var beforeEnterHook = isAppear 8473 ? (beforeAppear || beforeEnter) 8474 : beforeEnter; 8475 var enterHook = isAppear 8476 ? (typeof appear === 'function' ? appear : enter) 8477 : enter; 8478 var afterEnterHook = isAppear 8479 ? (afterAppear || afterEnter) 8480 : afterEnter; 8481 var enterCancelledHook = isAppear 8482 ? (appearCancelled || enterCancelled) 8483 : enterCancelled; 8484 8485 var explicitEnterDuration = toNumber( 8486 isObject(duration) 8487 ? duration.enter 8488 : duration 8489 ); 8490 8491 if (false) {} 8492 8493 var expectsCSS = css !== false && !isIE9; 8494 var userWantsControl = getHookArgumentsLength(enterHook); 8495 8496 var cb = el._enterCb = once(function () { 8497 if (expectsCSS) { 8498 removeTransitionClass(el, toClass); 8499 removeTransitionClass(el, activeClass); 8500 } 8501 if (cb.cancelled) { 8502 if (expectsCSS) { 8503 removeTransitionClass(el, startClass); 8504 } 8505 enterCancelledHook && enterCancelledHook(el); 8506 } else { 8507 afterEnterHook && afterEnterHook(el); 8508 } 8509 el._enterCb = null; 8510 }); 8511 8512 if (!vnode.data.show) { 8513 // remove pending leave element on enter by injecting an insert hook 8514 mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', function () { 8515 var parent = el.parentNode; 8516 var pendingNode = parent && parent._pending && parent._pending[vnode.key]; 8517 if (pendingNode && 8518 pendingNode.tag === vnode.tag && 8519 pendingNode.elm._leaveCb 8520 ) { 8521 pendingNode.elm._leaveCb(); 8522 } 8523 enterHook && enterHook(el, cb); 8524 }); 8525 } 8526 8527 // start enter transition 8528 beforeEnterHook && beforeEnterHook(el); 8529 if (expectsCSS) { 8530 addTransitionClass(el, startClass); 8531 addTransitionClass(el, activeClass); 8532 nextFrame(function () { 8533 addTransitionClass(el, toClass); 8534 removeTransitionClass(el, startClass); 8535 if (!cb.cancelled && !userWantsControl) { 8536 if (isValidDuration(explicitEnterDuration)) { 8537 setTimeout(cb, explicitEnterDuration); 8538 } else { 8539 whenTransitionEnds(el, type, cb); 8540 } 8541 } 8542 }); 8543 } 8544 8545 if (vnode.data.show) { 8546 toggleDisplay && toggleDisplay(); 8547 enterHook && enterHook(el, cb); 8548 } 8549 8550 if (!expectsCSS && !userWantsControl) { 8551 cb(); 8552 } 8553 } 8554 8555 function leave (vnode, rm) { 8556 var el = vnode.elm; 8557 8558 // call enter callback now 8559 if (isDef(el._enterCb)) { 8560 el._enterCb.cancelled = true; 8561 el._enterCb(); 8562 } 8563 8564 var data = resolveTransition(vnode.data.transition); 8565 if (isUndef(data)) { 8566 return rm() 8567 } 8568 8569 /* istanbul ignore if */ 8570 if (isDef(el._leaveCb) || el.nodeType !== 1) { 8571 return 8572 } 8573 8574 var css = data.css; 8575 var type = data.type; 8576 var leaveClass = data.leaveClass; 8577 var leaveToClass = data.leaveToClass; 8578 var leaveActiveClass = data.leaveActiveClass; 8579 var beforeLeave = data.beforeLeave; 8580 var leave = data.leave; 8581 var afterLeave = data.afterLeave; 8582 var leaveCancelled = data.leaveCancelled; 8583 var delayLeave = data.delayLeave; 8584 var duration = data.duration; 8585 8586 var expectsCSS = css !== false && !isIE9; 8587 var userWantsControl = getHookArgumentsLength(leave); 8588 8589 var explicitLeaveDuration = toNumber( 8590 isObject(duration) 8591 ? duration.leave 8592 : duration 8593 ); 8594 8595 if (false) {} 8596 8597 var cb = el._leaveCb = once(function () { 8598 if (el.parentNode && el.parentNode._pending) { 8599 el.parentNode._pending[vnode.key] = null; 8600 } 8601 if (expectsCSS) { 8602 removeTransitionClass(el, leaveToClass); 8603 removeTransitionClass(el, leaveActiveClass); 8604 } 8605 if (cb.cancelled) { 8606 if (expectsCSS) { 8607 removeTransitionClass(el, leaveClass); 8608 } 8609 leaveCancelled && leaveCancelled(el); 8610 } else { 8611 rm(); 8612 afterLeave && afterLeave(el); 8613 } 8614 el._leaveCb = null; 8615 }); 8616 8617 if (delayLeave) { 8618 delayLeave(performLeave); 8619 } else { 8620 performLeave(); 8621 } 8622 8623 function performLeave () { 8624 // the delayed leave may have already been cancelled 8625 if (cb.cancelled) { 8626 return 8627 } 8628 // record leaving element 8629 if (!vnode.data.show) { 8630 (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode; 8631 } 8632 beforeLeave && beforeLeave(el); 8633 if (expectsCSS) { 8634 addTransitionClass(el, leaveClass); 8635 addTransitionClass(el, leaveActiveClass); 8636 nextFrame(function () { 8637 addTransitionClass(el, leaveToClass); 8638 removeTransitionClass(el, leaveClass); 8639 if (!cb.cancelled && !userWantsControl) { 8640 if (isValidDuration(explicitLeaveDuration)) { 8641 setTimeout(cb, explicitLeaveDuration); 8642 } else { 8643 whenTransitionEnds(el, type, cb); 8644 } 8645 } 8646 }); 8647 } 8648 leave && leave(el, cb); 8649 if (!expectsCSS && !userWantsControl) { 8650 cb(); 8651 } 8652 } 8653 } 8654 8655 function isValidDuration (val) { 8656 return typeof val === 'number' && !isNaN(val) 8657 } 8658 8659 /** 8660 * Normalize a transition hook's argument length. The hook may be: 8661 * - a merged hook (invoker) with the original in .fns 8662 * - a wrapped component method (check ._length) 8663 * - a plain function (.length) 8664 */ 8665 function getHookArgumentsLength (fn) { 8666 if (isUndef(fn)) { 8667 return false 8668 } 8669 var invokerFns = fn.fns; 8670 if (isDef(invokerFns)) { 8671 // invoker 8672 return getHookArgumentsLength( 8673 Array.isArray(invokerFns) 8674 ? invokerFns[0] 8675 : invokerFns 8676 ) 8677 } else { 8678 return (fn._length || fn.length) > 1 8679 } 8680 } 8681 8682 function _enter (_, vnode) { 8683 if (vnode.data.show !== true) { 8684 enter(vnode); 8685 } 8686 } 8687 8688 var transition = inBrowser ? { 8689 create: _enter, 8690 activate: _enter, 8691 remove: function remove$$1 (vnode, rm) { 8692 /* istanbul ignore else */ 8693 if (vnode.data.show !== true) { 8694 leave(vnode, rm); 8695 } else { 8696 rm(); 8697 } 8698 } 8699 } : {}; 8700 8701 var platformModules = [ 8702 attrs, 8703 klass, 8704 events, 8705 domProps, 8706 style, 8707 transition 8708 ]; 8709 8710 /* */ 8711 8712 // the directive module should be applied last, after all 8713 // built-in modules have been applied. 8714 var modules = platformModules.concat(baseModules); 8715 8716 var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules }); 8717 8718 /** 8719 * Not type checking this file because flow doesn't like attaching 8720 * properties to Elements. 8721 */ 8722 8723 /* istanbul ignore if */ 8724 if (isIE9) { 8725 // http://www.matts411.com/post/internet-explorer-9-oninput/ 8726 document.addEventListener('selectionchange', function () { 8727 var el = document.activeElement; 8728 if (el && el.vmodel) { 8729 trigger(el, 'input'); 8730 } 8731 }); 8732 } 8733 8734 var model$1 = { 8735 inserted: function inserted (el, binding, vnode) { 8736 if (vnode.tag === 'select') { 8737 var cb = function () { 8738 setSelected(el, binding, vnode.context); 8739 }; 8740 cb(); 8741 /* istanbul ignore if */ 8742 if (isIE || isEdge) { 8743 setTimeout(cb, 0); 8744 } 8745 } else if (vnode.tag === 'textarea' || el.type === 'text' || el.type === 'password') { 8746 el._vModifiers = binding.modifiers; 8747 if (!binding.modifiers.lazy) { 8748 // Safari < 10.2 & UIWebView doesn't fire compositionend when 8749 // switching focus before confirming composition choice 8750 // this also fixes the issue where some browsers e.g. iOS Chrome 8751 // fires "change" instead of "input" on autocomplete. 8752 el.addEventListener('change', onCompositionEnd); 8753 if (!isAndroid) { 8754 el.addEventListener('compositionstart', onCompositionStart); 8755 el.addEventListener('compositionend', onCompositionEnd); 8756 } 8757 /* istanbul ignore if */ 8758 if (isIE9) { 8759 el.vmodel = true; 8760 } 8761 } 8762 } 8763 }, 8764 componentUpdated: function componentUpdated (el, binding, vnode) { 8765 if (vnode.tag === 'select') { 8766 setSelected(el, binding, vnode.context); 8767 // in case the options rendered by v-for have changed, 8768 // it's possible that the value is out-of-sync with the rendered options. 8769 // detect such cases and filter out values that no longer has a matching 8770 // option in the DOM. 8771 var needReset = el.multiple 8772 ? binding.value.some(function (v) { return hasNoMatchingOption(v, el.options); }) 8773 : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, el.options); 8774 if (needReset) { 8775 trigger(el, 'change'); 8776 } 8777 } 8778 } 8779 }; 8780 8781 function setSelected (el, binding, vm) { 8782 var value = binding.value; 8783 var isMultiple = el.multiple; 8784 if (isMultiple && !Array.isArray(value)) { 8785 "production" !== 'production' && warn$1( 8786 "<select multiple v-model=\"" + (binding.expression) + "\"> " + 8787 "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)), 8788 vm 8789 ); 8790 return 8791 } 8792 var selected, option; 8793 for (var i = 0, l = el.options.length; i < l; i++) { 8794 option = el.options[i]; 8795 if (isMultiple) { 8796 selected = looseIndexOf(value, getValue(option)) > -1; 8797 if (option.selected !== selected) { 8798 option.selected = selected; 8799 } 8800 } else { 8801 if (looseEqual(getValue(option), value)) { 8802 if (el.selectedIndex !== i) { 8803 el.selectedIndex = i; 8804 } 8805 return 8806 } 8807 } 8808 } 8809 if (!isMultiple) { 8810 el.selectedIndex = -1; 8811 } 8812 } 8813 8814 function hasNoMatchingOption (value, options) { 8815 for (var i = 0, l = options.length; i < l; i++) { 8816 if (looseEqual(getValue(options[i]), value)) { 8817 return false 8818 } 8819 } 8820 return true 8821 } 8822 8823 function getValue (option) { 8824 return '_value' in option 8825 ? option._value 8826 : option.value 8827 } 8828 8829 function onCompositionStart (e) { 8830 e.target.composing = true; 8831 } 8832 8833 function onCompositionEnd (e) { 8834 // prevent triggering an input event for no reason 8835 if (!e.target.composing) { return } 8836 e.target.composing = false; 8837 trigger(e.target, 'input'); 8838 } 8839 8840 function trigger (el, type) { 8841 var e = document.createEvent('HTMLEvents'); 8842 e.initEvent(type, true, true); 8843 el.dispatchEvent(e); 8844 } 8845 8846 /* */ 8847 8848 // recursively search for possible transition defined inside the component root 8849 function locateNode (vnode) { 8850 return vnode.componentInstance && (!vnode.data || !vnode.data.transition) 8851 ? locateNode(vnode.componentInstance._vnode) 8852 : vnode 8853 } 8854 8855 var show = { 8856 bind: function bind (el, ref, vnode) { 8857 var value = ref.value; 8858 8859 vnode = locateNode(vnode); 8860 var transition = vnode.data && vnode.data.transition; 8861 var originalDisplay = el.__vOriginalDisplay = 8862 el.style.display === 'none' ? '' : el.style.display; 8863 if (value && transition && !isIE9) { 8864 vnode.data.show = true; 8865 enter(vnode, function () { 8866 el.style.display = originalDisplay; 8867 }); 8868 } else { 8869 el.style.display = value ? originalDisplay : 'none'; 8870 } 8871 }, 8872 8873 update: function update (el, ref, vnode) { 8874 var value = ref.value; 8875 var oldValue = ref.oldValue; 8876 8877 /* istanbul ignore if */ 8878 if (value === oldValue) { return } 8879 vnode = locateNode(vnode); 8880 var transition = vnode.data && vnode.data.transition; 8881 if (transition && !isIE9) { 8882 vnode.data.show = true; 8883 if (value) { 8884 enter(vnode, function () { 8885 el.style.display = el.__vOriginalDisplay; 8886 }); 8887 } else { 8888 leave(vnode, function () { 8889 el.style.display = 'none'; 8890 }); 8891 } 8892 } else { 8893 el.style.display = value ? el.__vOriginalDisplay : 'none'; 8894 } 8895 }, 8896 8897 unbind: function unbind ( 8898 el, 8899 binding, 8900 vnode, 8901 oldVnode, 8902 isDestroy 8903 ) { 8904 if (!isDestroy) { 8905 el.style.display = el.__vOriginalDisplay; 8906 } 8907 } 8908 }; 8909 8910 var platformDirectives = { 8911 model: model$1, 8912 show: show 8913 }; 8914 8915 /* */ 8916 8917 // Provides transition support for a single element/component. 8918 // supports transition mode (out-in / in-out) 8919 8920 var transitionProps = { 8921 name: String, 8922 appear: Boolean, 8923 css: Boolean, 8924 mode: String, 8925 type: String, 8926 enterClass: String, 8927 leaveClass: String, 8928 enterToClass: String, 8929 leaveToClass: String, 8930 enterActiveClass: String, 8931 leaveActiveClass: String, 8932 appearClass: String, 8933 appearActiveClass: String, 8934 appearToClass: String, 8935 duration: [Number, String, Object] 8936 }; 8937 8938 // in case the child is also an abstract component, e.g. <keep-alive> 8939 // we want to recursively retrieve the real component to be rendered 8940 function getRealChild (vnode) { 8941 var compOptions = vnode && vnode.componentOptions; 8942 if (compOptions && compOptions.Ctor.options.abstract) { 8943 return getRealChild(getFirstComponentChild(compOptions.children)) 8944 } else { 8945 return vnode 8946 } 8947 } 8948 8949 function extractTransitionData (comp) { 8950 var data = {}; 8951 var options = comp.$options; 8952 // props 8953 for (var key in options.propsData) { 8954 data[key] = comp[key]; 8955 } 8956 // events. 8957 // extract listeners and pass them directly to the transition methods 8958 var listeners = options._parentListeners; 8959 for (var key$1 in listeners) { 8960 data[camelize(key$1)] = listeners[key$1]; 8961 } 8962 return data 8963 } 8964 8965 function placeholder (h, rawChild) { 8966 if (/\d-keep-alive$/.test(rawChild.tag)) { 8967 return h('keep-alive', { 8968 props: rawChild.componentOptions.propsData 8969 }) 8970 } 8971 } 8972 8973 function hasParentTransition (vnode) { 8974 while ((vnode = vnode.parent)) { 8975 if (vnode.data.transition) { 8976 return true 8977 } 8978 } 8979 } 8980 8981 function isSameChild (child, oldChild) { 8982 return oldChild.key === child.key && oldChild.tag === child.tag 8983 } 8984 8985 var Transition = { 8986 name: 'transition', 8987 props: transitionProps, 8988 abstract: true, 8989 8990 render: function render (h) { 8991 var this$1 = this; 8992 8993 var children = this.$slots.default; 8994 if (!children) { 8995 return 8996 } 8997 8998 // filter out text nodes (possible whitespaces) 8999 children = children.filter(function (c) { return c.tag; }); 9000 /* istanbul ignore if */ 9001 if (!children.length) { 9002 return 9003 } 9004 9005 // warn multiple elements 9006 if (false) {} 9007 9008 var mode = this.mode; 9009 9010 // warn invalid mode 9011 if (false 9012 ) {} 9013 9014 var rawChild = children[0]; 9015 9016 // if this is a component root node and the component's 9017 // parent container node also has transition, skip. 9018 if (hasParentTransition(this.$vnode)) { 9019 return rawChild 9020 } 9021 9022 // apply transition data to child 9023 // use getRealChild() to ignore abstract components e.g. keep-alive 9024 var child = getRealChild(rawChild); 9025 /* istanbul ignore if */ 9026 if (!child) { 9027 return rawChild 9028 } 9029 9030 if (this._leaving) { 9031 return placeholder(h, rawChild) 9032 } 9033 9034 // ensure a key that is unique to the vnode type and to this transition 9035 // component instance. This key will be used to remove pending leaving nodes 9036 // during entering. 9037 var id = "__transition-" + (this._uid) + "-"; 9038 child.key = child.key == null 9039 ? id + child.tag 9040 : isPrimitive(child.key) 9041 ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key) 9042 : child.key; 9043 9044 var data = (child.data || (child.data = {})).transition = extractTransitionData(this); 9045 var oldRawChild = this._vnode; 9046 var oldChild = getRealChild(oldRawChild); 9047 9048 // mark v-show 9049 // so that the transition module can hand over the control to the directive 9050 if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) { 9051 child.data.show = true; 9052 } 9053 9054 if (oldChild && oldChild.data && !isSameChild(child, oldChild)) { 9055 // replace old child transition data with fresh one 9056 // important for dynamic transitions! 9057 var oldData = oldChild && (oldChild.data.transition = extend({}, data)); 9058 // handle transition mode 9059 if (mode === 'out-in') { 9060 // return placeholder node and queue update when leave finishes 9061 this._leaving = true; 9062 mergeVNodeHook(oldData, 'afterLeave', function () { 9063 this$1._leaving = false; 9064 this$1.$forceUpdate(); 9065 }); 9066 return placeholder(h, rawChild) 9067 } else if (mode === 'in-out') { 9068 var delayedLeave; 9069 var performLeave = function () { delayedLeave(); }; 9070 mergeVNodeHook(data, 'afterEnter', performLeave); 9071 mergeVNodeHook(data, 'enterCancelled', performLeave); 9072 mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; }); 9073 } 9074 } 9075 9076 return rawChild 9077 } 9078 }; 9079 9080 /* */ 9081 9082 // Provides transition support for list items. 9083 // supports move transitions using the FLIP technique. 9084 9085 // Because the vdom's children update algorithm is "unstable" - i.e. 9086 // it doesn't guarantee the relative positioning of removed elements, 9087 // we force transition-group to update its children into two passes: 9088 // in the first pass, we remove all nodes that need to be removed, 9089 // triggering their leaving transition; in the second pass, we insert/move 9090 // into the final desired state. This way in the second pass removed 9091 // nodes will remain where they should be. 9092 9093 var props = extend({ 9094 tag: String, 9095 moveClass: String 9096 }, transitionProps); 9097 9098 delete props.mode; 9099 9100 var TransitionGroup = { 9101 props: props, 9102 9103 render: function render (h) { 9104 var tag = this.tag || this.$vnode.data.tag || 'span'; 9105 var map = Object.create(null); 9106 var prevChildren = this.prevChildren = this.children; 9107 var rawChildren = this.$slots.default || []; 9108 var children = this.children = []; 9109 var transitionData = extractTransitionData(this); 9110 9111 for (var i = 0; i < rawChildren.length; i++) { 9112 var c = rawChildren[i]; 9113 if (c.tag) { 9114 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { 9115 children.push(c); 9116 map[c.key] = c 9117 ;(c.data || (c.data = {})).transition = transitionData; 9118 } else if (false) {} 9119 } 9120 } 9121 9122 if (prevChildren) { 9123 var kept = []; 9124 var removed = []; 9125 for (var i$1 = 0; i$1 < prevChildren.length; i$1++) { 9126 var c$1 = prevChildren[i$1]; 9127 c$1.data.transition = transitionData; 9128 c$1.data.pos = c$1.elm.getBoundingClientRect(); 9129 if (map[c$1.key]) { 9130 kept.push(c$1); 9131 } else { 9132 removed.push(c$1); 9133 } 9134 } 9135 this.kept = h(tag, null, kept); 9136 this.removed = removed; 9137 } 9138 9139 return h(tag, null, children) 9140 }, 9141 9142 beforeUpdate: function beforeUpdate () { 9143 // force removing pass 9144 this.__patch__( 9145 this._vnode, 9146 this.kept, 9147 false, // hydrating 9148 true // removeOnly (!important, avoids unnecessary moves) 9149 ); 9150 this._vnode = this.kept; 9151 }, 9152 9153 updated: function updated () { 9154 var children = this.prevChildren; 9155 var moveClass = this.moveClass || ((this.name || 'v') + '-move'); 9156 if (!children.length || !this.hasMove(children[0].elm, moveClass)) { 9157 return 9158 } 9159 9160 // we divide the work into three loops to avoid mixing DOM reads and writes 9161 // in each iteration - which helps prevent layout thrashing.
9162 children.forEach(callPendingCbs); 9163 children.forEach(recordPosition); 9164 children.forEach(applyTranslation); 9165 9166 // force reflow to put everything in position 9167 var body = document.body; 9168 var f = body.offsetHeight; // eslint-disable-line 9169 9170 children.forEach(function (c) { 9171 if (c.data.moved) { 9172 var el = c.elm; 9173 var s = el.style; 9174 addTransitionClass(el, moveClass); 9175 s.transform = s.WebkitTransform = s.transitionDuration = ''; 9176 el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { 9177 if (!e || /transform$/.test(e.propertyName)) { 9178 el.removeEventListener(transitionEndEvent, cb); 9179 el._moveCb = null; 9180 removeTransitionClass(el, moveClass); 9181 } 9182 }); 9183 } 9184 }); 9185 }, 9186 9187 methods: { 9188 hasMove: function hasMove (el, moveClass) { 9189 /* istanbul ignore if */ 9190 if (!hasTransition) { 9191 return false 9192 } 9193 if (this._hasMove != null) { 9194 return this._hasMove 9195 } 9196 // Detect whether an element with the move class applied has 9197 // CSS transitions. Since the element may be inside an entering 9198 // transition at this very moment, we make a clone of it and remove 9199 // all other transition classes applied to ensure only the move class 9200 // is applied. 9201 var clone = el.cloneNode(); 9202 if (el._transitionClasses) { 9203 el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); }); 9204 } 9205 addClass(clone, moveClass); 9206 clone.style.display = 'none'; 9207 this.$el.appendChild(clone); 9208 var info = getTransitionInfo(clone); 9209 this.$el.removeChild(clone); 9210 return (this._hasMove = info.hasTransform) 9211 } 9212 } 9213 }; 9214 9215 function callPendingCbs (c) { 9216 /* istanbul ignore if */ 9217 if (c.elm._moveCb) { 9218 c.elm._moveCb(); 9219 } 9220 /* istanbul ignore if */ 9221 if (c.elm._enterCb) { 9222 c.elm._enterCb(); 9223 } 9224 } 9225 9226 function recordPosition (c) { 9227 c.data.newPos = c.elm.getBoundingClientRect(); 9228 } 9229 9230 function applyTranslation (c) { 9231 var oldPos = c.data.pos; 9232 var newPos = c.data.newPos; 9233 var dx = oldPos.left - newPos.left; 9234 var dy = oldPos.top - newPos.top; 9235 if (dx || dy) { 9236 c.data.moved = true; 9237 var s = c.elm.style; 9238 s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)"; 9239 s.transitionDuration = '0s'; 9240 } 9241 } 9242 9243 var platformComponents = { 9244 Transition: Transition, 9245 TransitionGroup: TransitionGroup 9246 }; 9247 9248 /* */ 9249 9250 // install platform specific utils 9251 Vue$3.config.mustUseProp = mustUseProp; 9252 Vue$3.config.isReservedTag = isReservedTag; 9253 Vue$3.config.isReservedAttr = isReservedAttr; 9254 Vue$3.config.getTagNamespace = getTagNamespace; 9255 Vue$3.config.isUnknownElement = isUnknownElement; 9256 9257 // install platform runtime directives & components 9258 extend(Vue$3.options.directives, platformDirectives); 9259 extend(Vue$3.options.components, platformComponents); 9260 9261 // install platform patch function 9262 Vue$3.prototype.__patch__ = inBrowser ? patch : noop; 9263 9264 // public mount method 9265 Vue$3.prototype.$mount = function ( 9266 el, 9267 hydrating 9268 ) { 9269 el = el && inBrowser ? query(el) : undefined; 9270 return mountComponent(this, el, hydrating) 9271 }; 9272 9273 // devtools global hook 9274 /* istanbul ignore next */ 9275 setTimeout(function () { 9276 if (config.devtools) { 9277 if (devtools) { 9278 devtools.emit('init', Vue$3); 9279 } else if (false) {} 9280 } 9281 if (false 9282 ) {} 9283 }, 0); 9284 9285 var LEFT_ARROW = '«' 9286 var RIGHT_ARROW = '»' 9287 var ELLIPSES = '…' 9288 9289 var LimitedLinksGenerator = function LimitedLinksGenerator (listOfPages, currentPage, limit) { 9290 this.listOfPages = listOfPages 9291 this.lastPage = listOfPages.length - 1 9292 this.currentPage = currentPage === this.lastPage 9293 ? this.lastPage - 1 9294 : currentPage 9295 this.limit = limit 9296 }; 9297 9298 LimitedLinksGenerator.prototype.generate = function generate () { 9299 var firstHalf = this._buildFirstHalf() 9300 var secondHalf = this._buildSecondHalf() 9301 return firstHalf.concat( secondHalf) 9302 }; 9303 9304 LimitedLinksGenerator.prototype._buildFirstHalf = function _buildFirstHalf () { 9305 var firstHalf = this._allPagesButLast() 9306 .slice( 9307 this._currentChunkIndex(), 9308 this._currentChunkIndex() + this.limit 9309 ) 9310 // Add backward ellipses with first page if needed 9311 if (this.currentPage >= this.limit) { 9312 firstHalf.unshift(ELLIPSES) 9313 firstHalf.unshift(0) 9314 } 9315 // Add ellipses if needed 9316 if (this.lastPage - this.limit > this._currentChunkIndex()) { 9317 firstHalf.push(ELLIPSES) 9318 } 9319 return firstHalf 9320 }; 9321 9322 LimitedLinksGenerator.prototype._buildSecondHalf = function _buildSecondHalf () { 9323 var secondHalf = [this.lastPage] 9324 return secondHalf 9325 }; 9326 9327 LimitedLinksGenerator.prototype._currentChunkIndex = function _currentChunkIndex () { 9328 var currentChunk = Math.floor(this.currentPage / this.limit) 9329 return currentChunk * this.limit 9330 }; 9331 9332 LimitedLinksGenerator.prototype._allPagesButLast = function _allPagesButLast () { 9333 var this$1 = this; 9334 9335 return this.listOfPages.filter(function (n) { return n !== this$1.lastPage; }) 9336 }; 9337 9338 var PaginateLinks = { 9339 name: 'paginate-links', 9340 props: { 9341 for: { 9342 type: String, 9343 required: true 9344 }, 9345 limit: { 9346 type: Number, 9347 default: 0 9348 }, 9349 simple: { 9350 type: Object, 9351 default: null, 9352 validator: function validator (obj) { 9353 return obj.prev && obj.next 9354 } 9355 }, 9356 stepLinks: { 9357 type: Object, 9358 default: function () { 9359 return { 9360 prev: LEFT_ARROW, 9361 next: RIGHT_ARROW 9362 } 9363 }, 9364 validator: function validator$1 (obj) { 9365 return obj.prev && obj.next 9366 } 9367 }, 9368 showStepLinks: { 9369 type: Boolean 9370 }, 9371 hideSinglePage: { 9372 type: Boolean 9373 }, 9374 classes: { 9375 type: Object, 9376 default: null 9377 }, 9378 async: { 9379 type: Boolean, 9380 default: false 9381 } 9382 }, 9383 data: function data () { 9384 return { 9385 listOfPages: [], 9386 numberOfPages: 0, 9387 target: null 9388 } 9389 }, 9390 computed: { 9391 currentPage: { 9392 get: function get () { 9393 if (this.$parent.paginate[this.for]) { 9394 return this.$parent.paginate[this.for].page 9395 } 9396 },
9397 set: function set (page) { 9398 this.$parent.paginate[this.for].page = page 9399 } 9400 } 9401 }, 9402 mounted: function mounted () { 9403 var this$1 = this; 9404 9405 if (this.simple && this.limit) { 9406 warn(("<paginate-links for=\"" + (this.for) + "\"> 'simple' and 'limit' props can't be used at the same time. In this case, 'simple' will take precedence, and 'limit' will be ignored."), this.$parent, 'warn') 9407 } 9408 if (this.simple && !this.simple.next) { 9409 warn(("<paginate-links for=\"" + (this.for) + "\"> 'simple' prop doesn't contain 'next' value."), this.$parent) 9410 } 9411 if (this.simple && !this.simple.prev) { 9412 warn(("<paginate-links for=\"" + (this.for) + "\"> 'simple' prop doesn't contain 'prev' value."), this.$parent) 9413 } 9414 if (this.stepLinks && !this.stepLinks.next) { 9415 warn(("<paginate-links for=\"" + (this.for) + "\"> 'step-links' prop doesn't contain 'next' value."), this.$parent) 9416 } 9417 if (this.stepLinks && !this.stepLinks.prev) { 9418 warn(("<paginate-links for=\"" + (this.for) + "\"> 'step-links' prop doesn't contain 'prev' value."), this.$parent) 9419 } 9420 Vue$3.nextTick(function () { 9421 this$1.updateListOfPages() 9422 }) 9423 }, 9424 watch: { 9425 '$parent.paginate': { 9426 handler: function handler () { 9427 this.updateListOfPages() 9428 }, 9429 deep: true 9430 }, 9431 currentPage: function currentPage (toPage, fromPage) { 9432 this.$emit('change', toPage + 1, fromPage + 1) 9433 } 9434 }, 9435 methods: { 9436 updateListOfPages: function updateListOfPages () { 9437 this.target = getTargetPaginateComponent(this.$parent.$children, this.for) 9438 if (!this.target) { 9439 if (this.async) { return } 9440 warn(("<paginate-links for=\"" + (this.for) + "\"> can't be used without its companion <paginate name=\"" + (this.for) + "\">"), this.$parent) 9441 warn("To fix that issue you may need to use :async=\"true\" on <paginate-links> component to allow for asyncronous rendering", this.$parent, 'warn') 9442 return 9443 } 9444 this.numberOfPages = Math.ceil(this.target.list.length / this.target.per) 9445 this.listOfPages = getListOfPageNumbers(this.numberOfPages) 9446 } 9447 }, 9448 render: function render (h) { 9449 var this$1 = this; 9450 9451 if (!this.target && this.async) { return null } 9452 9453 var links = this.simple 9454 ? getSimpleLinks(this, h) 9455 : this.limit > 1 9456 ? getLimitedLinks(this, h) 9457 : getFullLinks(this, h) 9458 9459 if (this.hideSinglePage && this.numberOfPages <= 1) { 9460 return null 9461 } 9462 9463 var el = h('ul', { 9464 class: ['paginate-links', this.for] 9465 }, links) 9466 9467 if (this.classes) { 9468 Vue$3.nextTick(function () { 9469 addAdditionalClasses(el.elm, this$1.classes) 9470 }) 9471 } 9472 return el 9473 } 9474 } 9475 9476 function getFullLinks (vm, h) { 9477 var allLinks = vm.showStepLinks 9478 ? [vm.stepLinks.prev ].concat( vm.listOfPages, [vm.stepLinks.next]) 9479 : vm.listOfPages 9480 return allLinks.map(function (link) { 9481 var data = { 9482 on: { 9483 click: function (e) { 9484 e.preventDefault() 9485 vm.currentPage = getTargetPageForLink( 9486 link, 9487 vm.limit, 9488 vm.currentPage, 9489 vm.listOfPages, 9490 vm.stepLinks 9491 ) 9492 } 9493 } 9494 } 9495 var liClasses = getClassesForLink( 9496 link, 9497 vm.currentPage, 9498 vm.listOfPages.length - 1, 9499 vm.stepLinks 9500 ) 9501 var linkText = link === vm.stepLinks.next || link === vm.stepLinks.prev 9502 ? link 9503 : link + 1 // it means it's a number 9504 return h('li', { class: liClasses }, [h('a', data, linkText)]) 9505 }) 9506 } 9507 9508 function getLimitedLinks (vm, h) { 9509 var limitedLinks = new LimitedLinksGenerator( 9510 vm.listOfPages, 9511 vm.currentPage, 9512 vm.limit, 9513 vm.stepLinks 9514 ).generate() 9515 9516 limitedLinks = vm.showStepLinks 9517 ? [vm.stepLinks.prev ].concat( limitedLinks, [vm.stepLinks.next]) 9518 : limitedLinks 9519 9520 var limitedLinksMetadata = getLimitedLinksMetadata(limitedLinks) 9521 9522 return limitedLinks.map(function (link, index) { 9523 var data = { 9524 on: { 9525 click: function (e) { 9526 e.preventDefault() 9527 vm.currentPage = getTargetPageForLink( 9528 link, 9529 vm.limit, 9530 vm.currentPage, 9531 vm.listOfPages, 9532 vm.stepLinks, 9533 limitedLinksMetadata[index] 9534 ) 9535 } 9536 } 9537 } 9538 var liClasses = getClassesForLink( 9539 link, 9540 vm.currentPage, 9541 vm.listOfPages.length - 1, 9542 vm.stepLinks 9543 ) 9544 // If the link is a number, 9545 // then incremented by 1 (since it's 0 based). 9546 // otherwise, do nothing (so, it's a symbol). 9547 var text = Number.isInteger(link) ? link + 1 : link 9548 return h('li', { class: liClasses }
9548, [h('a', data, text)]) 9549 }) 9550 } 9551 9552 function getSimpleLinks (vm, h) { 9553 var lastPage = vm.listOfPages.length - 1 9554 var prevData = { 9555 on: { 9556 click: function (e) { 9557 e.preventDefault() 9558 if (vm.currentPage > 0) { vm.currentPage -= 1 } 9559 } 9560 } 9561 } 9562 var nextData = { 9563 on: { 9564 click: function (e) { 9565 e.preventDefault() 9566 if (vm.currentPage < lastPage) { vm.currentPage += 1 } 9567 } 9568 } 9569 } 9570 var nextListData = { class: ['next', vm.currentPage >= lastPage ? 'disabled' : ''] } 9571 var prevListData = { class: ['prev', vm.currentPage <= 0 ? 'disabled' : ''] } 9572 var prevLink = h('li', prevListData, [h('a', prevData, vm.simple.prev)]) 9573 var nextLink = h('li', nextListData, [h('a', nextData, vm.simple.next)]) 9574 return [prevLink, nextLink] 9575 } 9576 9577 function getTargetPaginateComponent (children, targetName) { 9578 return children 9579 .filter(function (child) { return (child.$vnode.componentOptions.tag === 'paginate'); }) 9580 .find(function (child) { return child.name === targetName; }) 9581 } 9582 9583 function getListOfPageNumbers (numberOfPages) { 9584 // converts number of pages into an array 9585 // that contains each individual page number 9586 // For Example: 4 => [0, 1, 2, 3] 9587 return Array.apply(null, { length: numberOfPages }) 9588 .map(function (val, index) { return index; }) 9589 } 9590 9591 function getClassesForLink(link, currentPage, lastPage, ref) { 9592 var prev = ref.prev; 9593 var next = ref.next; 9594 9595 var liClass = [] 9596 if (link === prev) { 9597 liClass.push('left-arrow') 9598 } else if (link === next) { 9599 liClass.push('right-arrow') 9600 } else if (link === ELLIPSES) { 9601 liClass.push('ellipses') 9602 } else { 9603 liClass.push('number') 9604 } 9605 9606 if (link === currentPage) { 9607 liClass.push('active') 9608 } 9609 9610 if (link === prev && currentPage <= 0) { 9611 liClass.push('disabled') 9612 } else if (link === next && currentPage >= lastPage) { 9613 liClass.push('disabled') 9614 } 9615 return liClass 9616 } 9617 9618 function getTargetPageForLink (link, limit, currentPage, listOfPages, ref, metaData) { 9619 var prev = ref.prev; 9620 var next = ref.next; 9621 if ( metaData === void 0 ) metaData = null; 9622 9623 var currentChunk = Math.floor(currentPage / limit) 9624 if (link === prev) { 9625 return (currentPage - 1) < 0 ? 0 : currentPage - 1 9626 } else if (link === next) { 9627 return (currentPage + 1 > listOfPages.length - 1) 9628 ? listOfPages.length - 1 9629 : currentPage + 1 9630 } else if (metaData && metaData === 'right-ellipses') { 9631 return (currentChunk + 1) * limit 9632 } else if (metaData && metaData === 'left-ellipses') { 9633 var chunkContent = listOfPages.slice(currentChunk * limit, currentChunk * limit + limit) 9634 var isLastPage = currentPage === listOfPages.length - 1 9635 if (isLastPage && chunkContent.length === 1) { 9636 currentChunk-- 9637 } 9638 return (currentChunk - 1) * limit + limit - 1 9639 } 9640 // which is number 9641 return link 9642 } 9643 9644 /** 9645 * Mainly used here to check whether the displayed 9646 * ellipses is for showing previous or next links 9647 */ 9648 function getLimitedLinksMetadata (limitedLinks) { 9649 return limitedLinks.map(function (link, index) { 9650 if (link === ELLIPSES && limitedLinks[index - 1] === 0) { 9651 return 'left-ellipses' 9652 } else if (link === ELLIPSES && limitedLinks[index - 1] !== 0) { 9653 return 'right-ellipses' 9654 } 9655 return link 9656 }) 9657 } 9658 9659 function addAdditionalClasses (linksContainer, classes) { 9660 Object.keys(classes).forEach(function (selector) { 9661 if (selector === 'ul') { 9662 var selectorValue = classes['ul'] 9663 if (Array.isArray(selectorValue)) { 9664 selectorValue.forEach(function (c) { return linksContainer.classList.add(c); }) 9665 } else { 9666 linksContainer.classList.add(selectorValue) 9667 } 9668 } 9669 linksContainer.querySelectorAll(selector).forEach(function (node) { 9670 var selectorValue = classes[selector] 9671 if (Array.isArray(selectorValue)) { 9672 selectorValue.forEach(function (c) { return node.classList.add(c); }) 9673 } else { 9674 node.classList.add(selectorValue) 9675 } 9676 }) 9677 }) 9678 } 9679 9680 function paginateDataGenerator (listNames) { 9681 if ( listNames === void 0 ) listNames = []; 9682 9683 return listNames.reduce(function (curr, listName) { 9684 curr[listName] = { 9685 list: [], 9686 page: 0 9687 } 9688 return curr 9689 }, {}) 9690 } 9691 9692 var vuePaginate = {} 9693 9694 vuePaginate.install = function (Vue) { 9695 Vue.mixin({ 9696 created: function created () { 9697 if (this.paginate !== 'undefined' && this.paginate instanceof Array) { 9698 this.paginate = paginateDataGenerator(this.paginate) 9699 } 9700 }, 9701 methods: { 9702 paginated: function paginated (listName) { 9703 if (!this.paginate || !this.paginate[listName]) { 9704 warn(("'" + listName + "' is not registered in 'paginate' array."), this) 9705 return 9706 } 9707 return this.paginate[listName].list 9708 } 9709 } 9710 }) 9711 Vue.component('paginate', Paginate) 9712 Vue.component('paginate-links', PaginateLinks) 9713 } 9714 9715 if (typeof window !== 'undefined' && window.Vue) { 9716 window.Vue.use(vuePaginate) 9717 } 9718 9719 return vuePaginate; 9720 9721})); 9722/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) 9723 9724/***/ }), 9725/* 33 */ 9726/***/ (function(module, exports, __webpack_require__) { 9727 9728// style-loader: Adds some css to the DOM by adding a <style> tag 9729 9730// load the styles
vendor: 44,991 bytes, lines 9731-11607
9731var content = __webpack_require__(24); 9732if(typeof content === 'string') content = [[module.i, content, '']]; 9733if(content.locals) module.exports = content.locals; 9734// add the styles to the DOM 9735var update = __webpack_require__(34)("23c840fa", content, false); 9736// Hot Module Replacement 9737if(false) { 9738 // When the styles change, update the <style> tags 9739 if(!content.locals) { 9740 module.hot.accept("!!../../../node_modules/css-loader/index.js!../../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-5c5dc322!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Maps.vue", function() { 9741 var newContent = require("!!../../../node_modules/css-loader/index.js!../../../node_modules/vue-loader/lib/style-rewriter.js?id=data-v-5c5dc322!../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./Maps.vue"); 9742 if(typeof newContent === 'string') newContent = [[module.id, newContent, '']]; 9743 update(newContent); 9744 }); 9745 } 9746 // When the module is disposed, remove the <style> tags 9747 module.hot.dispose(function() { update(); }); 9748} 9749 9750/***/ }), 9751/* 34 */ 9752/***/ (function(module, exports, __webpack_require__) { 9753 9754/* 9755 MIT License http://www.opensource.org/licenses/mit-license.php 9756 Author Tobias Koppers @sokra 9757 Modified by Evan You @yyx990803 9758*/ 9759 9760var hasDocument = typeof document !== 'undefined' 9761 9762if (typeof DEBUG !== 'undefined' && DEBUG) { 9763 if (!hasDocument) { 9764 throw new Error( 9765 'vue-style-loader cannot be used in a non-browser environment. ' + 9766 "Use { target: 'node' } in your Webpack config to indicate a server-rendering environment." 9767 ) } 9768} 9769 9770var listToStyles = __webpack_require__(35) 9771 9772/* 9773type StyleObject = { 9774 id: number; 9775 parts: Array<StyleObjectPart> 9776} 9777 9778type StyleObjectPart = { 9779 css: string; 9780 media: string; 9781 sourceMap: ?string 9782} 9783*/ 9784 9785var stylesInDom = {/* 9786 [id: number]: { 9787 id: number, 9788 refs: number, 9789 parts: Array<(obj?: StyleObjectPart) => void> 9790 } 9791*/} 9792 9793var head = hasDocument && (document.head || document.getElementsByTagName('head')[0]) 9794var singletonElement = null 9795var singletonCounter = 0 9796var isProduction = false 9797var noop = function () {} 9798 9799// Force single-tag solution on IE6-9, which has a hard limit on the # of <style> 9800// tags it will allow on a page 9801var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase()) 9802 9803module.exports = function (parentId, list, _isProduction) { 9804 isProduction = _isProduction 9805 9806 var styles = listToStyles(parentId, list) 9807 addStylesToDom(styles) 9808 9809 return function update (newList) { 9810 var mayRemove = [] 9811 for (var i = 0; i < styles.length; i++) { 9812 var item = styles[i] 9813 var domStyle = stylesInDom[item.id] 9814 domStyle.refs-- 9815 mayRemove.push(domStyle) 9816 } 9817 if (newList) { 9818 styles = listToStyles(parentId, newList) 9819 addStylesToDom(styles) 9820 } else { 9821 styles = [] 9822 } 9823 for (var i = 0; i < mayRemove.length; i++) { 9824 var domStyle = mayRemove[i] 9825 if (domStyle.refs === 0) { 9826 for (var j = 0; j < domStyle.parts.length; j++) { 9827 domStyle.parts[j]() 9828 } 9829 delete stylesInDom[domStyle.id] 9830 } 9831 } 9832 } 9833} 9834 9835function addStylesToDom (styles /* Array<StyleObject> */) { 9836 for (var i = 0; i < styles.length; i++) { 9837 var item = styles[i] 9838 var domStyle = stylesInDom[item.id] 9839 if (domStyle) { 9840 domStyle.refs++ 9841 for (var j = 0; j < domStyle.parts.length; j++) { 9842 domStyle.parts[j](item.parts[j]) 9843 } 9844 for (; j < item.parts.length; j++) { 9845 domStyle.parts.push(addStyle(item.parts[j])) 9846 } 9847 if (domStyle.parts.length > item.parts.length) { 9848 domStyle.parts.length = item.parts.length 9849 } 9850 } else { 9851 var parts = [] 9852 for (var j = 0; j < item.parts.length; j++) { 9853 parts.push(addStyle(item.parts[j])) 9854 } 9855 stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts } 9856 } 9857 } 9858} 9859 9860function createStyleElement () { 9861 var styleElement = document.createElement('style') 9862 styleElement.type = 'text/css' 9863 head.appendChild(styleElement) 9864 return styleElement 9865} 9866 9867function addStyle (obj /* StyleObjectPart */) { 9868 var update, remove 9869 var styleElement = document.querySelector('style[data-vue-ssr-id~="' + obj.id + '"]') 9870 9871 if (styleElement) { 9872 if (isProduction) { 9873 // has SSR styles and in production mode. 9874 // simply do nothing. 9875 return noop 9876 } else { 9877 // has SSR styles but in dev mode. 9878 // for some reason Chrome can't handle source map in server-rendered 9879 // style tags - source maps in <style> only works if the style tag is 9880 // created and inserted dynamically. So we remove the server rendered 9881 // styles and inject new ones. 9882 styleElement.parentNode.removeChild(styleElement) 9883 } 9884 } 9885 9886 if (isOldIE) { 9887 // use singleton mode for IE9. 9888 var styleIndex = singletonCounter++ 9889 styleElement = singletonElement || (singletonElement = createStyleElement()) 9890 update = applyToSingletonTag.bind(null, styleElement, styleIndex, false) 9891 remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true) 9892 } else { 9893 // use multi-style-tag mode in all other cases 9894 styleElement = createStyleElement() 9895 update = applyToTag.bind(null, styleElement) 9896 remove = function () { 9897 styleElement.parentNode.removeChild(styleElement) 9898 } 9899 } 9900 9901 update(obj) 9902 9903 return function updateStyle (newObj /* StyleObjectPart */) { 9904 if (newObj) { 9905 if (newObj.css === obj.css && 9906 newObj.media === obj.media && 9907 newObj.sourceMap === obj.sourceMap) { 9908 return 9909 } 9910 update(obj = newObj) 9911 } else { 9912 remove() 9913 } 9914 } 9915} 9916 9917var replaceText = (function () { 9918 var textStore = [] 9919 9920 return function (index, replacement) { 9921 textStore[index] = replacement 9922 return textStore.filter(Boolean).join('\n') 9923 } 9924})() 9925 9926function applyToSingletonTag (styleElement, index, remove, obj) { 9927 var css = remove ? '' : obj.css 9928 9929 if (styleElement.styleSheet) { 9930 styleElement.styleSheet.cssText = replaceText(index, css) 9931 } else { 9932 var cssNode = document.createTextNode(css) 9933 var childNodes = styleElement.childNodes 9934 if (childNodes[index]) styleElement.removeChild(childNodes[index]) 9935 if (childNodes.length) { 9936 styleElement.insertBefore(cssNode, childNodes[index]) 9937 } else { 9938 styleElement.appendChild(cssNode) 9939 } 9940 } 9941} 9942 9943function applyToTag (styleElement, obj) { 9944 var css = obj.css 9945 var media = obj.media 9946 var sourceMap = obj.sourceMap 9947 9948 if (media) { 9949 styleElement.setAttribute('media', media) 9950 } 9951 9952 if (sourceMap) { 9953 // https://developer.chrome.com/devtools/docs/javascript-debugging 9954 // this makes source maps inside style tags work properly in Chrome 9955 css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */' 9956 // http://stackoverflow.com/a/26603875 9957 css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */' 9958 } 9959 9960 if (styleElement.styleSheet) { 9961 styleElement.styleSheet.cssText = css 9962 } else { 9963 while (styleElement.firstChild) { 9964 styleElement.removeChild(styleElement.firstChild) 9965 } 9966 styleElement.appendChild(document.createTextNode(css)) 9967 } 9968} 9969 9970 9971/***/ }), 9972/* 35 */ 9973/***/ (function(module, exports) { 9974 9975/** 9976 * Translates the list format produced by css-loader into something 9977 * easier to manipulate. 9978 */ 9979module.exports = function listToStyles (parentId, list) { 9980 var styles = [] 9981 var newStyles = {} 9982 for (var i = 0; i < list.length; i++) { 9983 var item = list[i] 9984 var id = item[0] 9985 var css = item[1] 9986 var media = item[2] 9987 var sourceMap = item[3] 9988 var part = { 9989 id: parentId + ':' + i, 9990 css: css, 9991 media: media, 9992 sourceMap: sourceMap 9993 } 9994 if (!newStyles[id]) { 9995 styles.push(newStyles[id] = { id: id, parts: [part] }) 9996 } else { 9997 newStyles[id].parts.push(part) 9998 } 9999 } 10000 return styles 10001} 10002 10003 10004/***/ }), 10005/* 36 */ 10006/***/ (function(module, exports, __webpack_require__) { 10007 10008"use strict"; 10009/* WEBPACK VAR INJECTION */(function(process, global, setImmediate) {/*! 10010 * Vue.js v2.5.8 10011 * (c) 2014-2017 Evan You 10012 * Released under the MIT License. 10013 */ 10014 10015 10016/* */ 10017 10018var emptyObject = Object.freeze({}); 10019 10020// these helpers produces better vm code in JS engines due to their 10021// explicitness and function inlining 10022function isUndef (v) { 10023 return v === undefined || v === null 10024} 10025 10026function isDef (v) { 10027 return v !== undefined && v !== null 10028} 10029 10030function isTrue (v) { 10031 return v === true 10032} 10033 10034function isFalse (v) { 10035 return v === false 10036} 10037 10038/** 10039 * Check if value is primitive 10040 */ 10041function isPrimitive (value) { 10042 return ( 10043 typeof value === 'string' || 10044 typeof value === 'number' || 10045 typeof value === 'boolean' 10046 ) 10047} 10048 10049/** 10050 * Quick object check - this is primarily used to tell 10051 * Objects from primitive values when we know the value 10052 * is a JSON-compliant type. 10053 */ 10054function isObject (obj) { 10055 return obj !== null && typeof obj === 'object' 10056} 10057 10058/** 10059 * Get the raw type string of a value e.g. [object Object] 10060 */ 10061var _toString = Object.prototype.toString; 10062 10063function toRawType (value) { 10064 return _toString.call(value).slice(8, -1) 10065} 10066 10067/** 10068 * Strict object type check. Only returns true 10069 * for plain JavaScript objects. 10070 */ 10071function isPlainObject (obj) { 10072 return _toString.call(obj) === '[object Object]' 10073} 10074 10075function isRegExp (v) { 10076 return _toString.call(v) === '[object RegExp]' 10077} 10078 10079/** 10080 * Check if val is a valid array index. 10081 */ 10082function isValidArrayIndex (val) { 10083 var n = parseFloat(String(val)); 10084 return n >= 0 && Math.floor(n) === n && isFinite(val) 10085} 10086 10087/** 10088 * Convert a value to a string that is actually rendered. 10089 */ 10090function toString (val) { 10091 return val == null 10092 ? '' 10093 : typeof val === 'object' 10094 ? JSON.stringify(val, null, 2) 10095 : String(val) 10096} 10097 10098/** 10099 * Convert a input value to a number for persistence. 10100 * If the conversion fails, return original string. 10101 */ 10102function toNumber (val) { 10103 var n = parseFloat(val); 10104 return isNaN(n) ? val : n 10105} 10106 10107/** 10108 * Make a map and return a function for checking if a key 10109 * is in that map. 10110 */ 10111function makeMap ( 10112 str, 10113 expectsLowerCase 10114) { 10115 var map = Object.create(null); 10116 var list = str.split(','); 10117 for (var i = 0; i < list.length; i++) { 10118 map[list[i]] = true; 10119 } 10120 return expectsLowerCase 10121 ? function (val) { return map[val.toLowerCase()]; } 10122 : function (val) { return map[val]; } 10123} 10124 10125/** 10126 * Check if a tag is a built-in tag. 10127 */ 10128var isBuiltInTag = makeMap('slot,component', true); 10129 10130/** 10131 * Check if a attribute is a reserved attribute. 10132 */ 10133var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); 10134 10135/** 10136 * Remove an item from an array 10137 */ 10138function remove (arr, item) { 10139 if (arr.length) { 10140 var index = arr.indexOf(item); 10141 if (index > -1) { 10142 return arr.splice(index, 1) 10143 } 10144 } 10145} 10146 10147/** 10148 * Check whether the object has the property. 10149 */ 10150var hasOwnProperty = Object.prototype.hasOwnProperty; 10151function hasOwn (obj, key) { 10152 return hasOwnProperty.call(obj, key) 10153} 10154 10155/** 10156 * Create a cached version of a pure function. 10157 */ 10158function cached (fn) { 10159 var cache = Object.create(null); 10160 return (function cachedFn (str) { 10161 var hit = cache[str]; 10162 return hit || (cache[str] = fn(str)) 10163 }) 10164} 10165 10166/** 10167 * Camelize a hyphen-delimited string. 10168 */ 10169var camelizeRE = /-(\w)/g; 10170var camelize = cached(function (str) { 10171 return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; }) 10172}); 10173 10174/** 10175 * Capitalize a string. 10176 */ 10177var capitalize = cached(function (str) { 10178 return str.charAt(0).toUpperCase() + str.slice(1) 10179}); 10180 10181/** 10182 * Hyphenate a camelCase string. 10183 */ 10184var hyphenateRE = /\B([A-Z])/g; 10185var hyphenate = cached(function (str) { 10186 return str.replace(hyphenateRE, '-$1').toLowerCase() 10187}); 10188 10189/** 10190 * Simple bind, faster than native 10191 */ 10192function bind (fn, ctx) { 10193 function boundFn (a) { 10194 var l = arguments.length; 10195 return l 10196 ? l > 1 10197 ? fn.apply(ctx, arguments) 10198 : fn.call(ctx, a) 10199 : fn.call(ctx) 10200 } 10201 // record original fn length 10202 boundFn._length = fn.length; 10203 return boundFn 10204} 10205 10206/** 10207 * Convert an Array-like object to a real Array. 10208 */ 10209function toArray (list, start) { 10210 start = start || 0; 10211 var i = list.length - start; 10212 var ret = new Array(i); 10213 while (i--) { 10214 ret[i] = list[i + start]; 10215 } 10216 return ret 10217} 10218 10219/** 10220 * Mix properties into target object. 10221 */ 10222function extend (to, _from) { 10223 for (var key in _from) { 10224 to[key] = _from[key]; 10225 } 10226 return to 10227} 10228 10229/** 10230 * Merge an Array of Objects into a single Object. 10231 */ 10232function toObject (arr) { 10233 var res = {}; 10234 for (var i = 0; i < arr.length; i++) { 10235 if (arr[i]) { 10236 extend(res, arr[i]); 10237 } 10238 } 10239 return res 10240} 10241 10242/** 10243 * Perform no operation. 10244 * Stubbing args to make Flow happy without leaving useless transpiled code 10245 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/) 10246 */ 10247function noop (a, b, c) {} 10248 10249/** 10250 * Always return false. 10251 */ 10252var no = function (a, b, c) { return false; }; 10253 10254/** 10255 * Return same value 10256 */ 10257var identity = function (_) { return _; }; 10258 10259/** 10260 * Generate a static keys string from compiler modules. 10261 */ 10262function genStaticKeys (modules) { 10263 return modules.reduce(function (keys, m) { 10264 return keys.concat(m.staticKeys || []) 10265 }, []).join(',') 10266} 10267 10268/** 10269 * Check if two values are loosely equal - that is, 10270 * if they are plain objects, do they have the same shape? 10271 */ 10272function looseEqual (a, b) { 10273 if (a === b) { return true } 10274 var isObjectA = isObject(a); 10275 var isObjectB = isObject(b); 10276 if (isObjectA && isObjectB) { 10277 try { 10278 var isArrayA = Array.isArray(a); 10279 var isArrayB = Array.isArray(b); 10280 if (isArrayA && isArrayB) { 10281 return a.length === b.length && a.every(function (e, i) { 10282 return looseEqual(e, b[i]) 10283 }) 10284 } else if (!isArrayA && !isArrayB) { 10285 var keysA = Object.keys(a); 10286 var keysB = Object.keys(b); 10287 return keysA.length === keysB.length && keysA.every(function (key) { 10288 return looseEqual(a[key], b[key]) 10289 }) 10290 } else { 10291 /* istanbul ignore next */ 10292 return false 10293 } 10294 } catch (e) { 10295 /* istanbul ignore next */ 10296 return false 10297 } 10298 } else if (!isObjectA && !isObjectB) { 10299 return String(a) === String(b) 10300 } else { 10301 return false 10302 } 10303} 10304 10305function looseIndexOf (arr, val) { 10306 for (var i = 0; i < arr.length; i++) { 10307 if (looseEqual(arr[i], val)) { return i } 10308 } 10309 return -1 10310} 10311 10312/** 10313 * Ensure a function is called only once. 10314 */ 10315function once (fn) { 10316 var called = false; 10317 return function () { 10318 if (!called) { 10319 called = true; 10320 fn.apply(this, arguments); 10321 } 10322 } 10323} 10324 10325var SSR_ATTR = 'data-server-rendered'; 10326 10327var ASSET_TYPES = [ 10328 'component', 10329 'directive', 10330 'filter' 10331]; 10332 10333var LIFECYCLE_HOOKS = [ 10334 'beforeCreate', 10335 'created', 10336 'beforeMount', 10337 'mounted', 10338 'beforeUpdate', 10339 'updated', 10340 'beforeDestroy', 10341 'destroyed', 10342 'activated', 10343 'deactivated', 10344 'errorCaptured' 10345]; 10346 10347/* */ 10348 10349var config = ({ 10350 /** 10351 * Option merge strategies (used in core/util/options) 10352 */ 10353 optionMergeStrategies: Object.create(null), 10354 10355 /** 10356 * Whether to suppress warnings. 10357 */ 10358 silent: false, 10359 10360 /** 10361 * Show production mode tip message on boot? 10362 */ 10363 productionTip: process.env.NODE_ENV !== 'production', 10364 10365 /** 10366 * Whether to enable devtools 10367 */ 10368 devtools: process.env.NODE_ENV !== 'production', 10369 10370 /** 10371 * Whether to record perf 10372 */ 10373 performance: false, 10374 10375 /** 10376 * Error handler for watcher errors 10377 */ 10378 errorHandler: null, 10379 10380 /** 10381 * Warn handler for watcher warns 10382 */ 10383 warnHandler: null, 10384 10385 /** 10386 * Ignore certain custom elements 10387 */ 10388 ignoredElements: [], 10389 10390 /** 10391 * Custom user key aliases for v-on 10392 */ 10393 keyCodes: Object.create(null), 10394 10395 /** 10396 * Check if a tag is reserved so that it cannot be registered as a 10397 * component. This is platform-dependent and may be overwritten. 10398 */ 10399 isReservedTag: no, 10400 10401 /** 10402 * Check if an attribute is reserved so that it cannot be used as a component 10403 * prop. This is platform-dependent and may be overwritten. 10404 */ 10405 isReservedAttr: no, 10406 10407 /** 10408 * Check if a tag is an unknown element. 10409 * Platform-dependent. 10410 */ 10411 isUnknownElement: no, 10412 10413 /** 10414 * Get the namespace of an element 10415 */ 10416 getTagNamespace: noop, 10417 10418 /** 10419 * Parse the real tag name for the specific platform. 10420 */ 10421 parsePlatformTagName: identity, 10422 10423 /** 10424 * Check if an attribute must be bound using property, e.g. value 10425 * Platform-dependent. 10426 */ 10427 mustUseProp: no, 10428 10429 /** 10430 * Exposed for legacy reasons 10431 */ 10432 _lifecycleHooks: LIFECYCLE_HOOKS 10433}); 10434 10435/* */ 10436 10437/** 10438 * Check if a string starts with $ or _ 10439 */ 10440function isReserved (str) { 10441 var c = (str + '').charCodeAt(0); 10442 return c === 0x24 || c === 0x5F 10443} 10444 10445/** 10446 * Define a property. 10447 */ 10448function def (obj, key, val, enumerable) { 10449 Object.defineProperty(obj, key, { 10450 value: val, 10451 enumerable: !!enumerable, 10452 writable: true, 10453 configurable: true 10454 }); 10455} 10456 10457/** 10458 * Parse simple path. 10459 */ 10460var bailRE = /[^\w.$]/; 10461function parsePath (path) { 10462 if (bailRE.test(path)) { 10463 return 10464 } 10465 var segments = path.split('.'); 10466 return function (obj) { 10467 for (var i = 0; i < segments.length; i++) { 10468 if (!obj) { return } 10469 obj = obj[segments[i]]; 10470 } 10471 return obj 10472 } 10473} 10474 10475/* */ 10476 10477 10478// can we use __proto__? 10479var hasProto = '__proto__' in {}; 10480 10481// Browser environment sniffing 10482var inBrowser = typeof window !== 'undefined'; 10483var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; 10484var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); 10485var UA = inBrowser && window.navigator.userAgent.toLowerCase(); 10486var isIE = UA && /msie|trident/.test(UA); 10487var isIE9 = UA && UA.indexOf('msie 9.0') > 0; 10488var isEdge = UA && UA.indexOf('edge/') > 0; 10489var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android'); 10490var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios'); 10491var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; 10492 10493// Firefox has a "watch" function on Object.prototype... 10494var nativeWatch = ({}).watch; 10495 10496var supportsPassive = false; 10497if (inBrowser) { 10498 try { 10499 var opts = {}; 10500 Object.defineProperty(opts, 'passive', ({ 10501 get: function get () { 10502 /* istanbul ignore next */ 10503 supportsPassive = true; 10504 } 10505 })); // https://github.com/facebook/flow/issues/285 10506 window.addEventListener('test-passive', null, opts); 10507 } catch (e) {} 10508} 10509 10510// this needs to be lazy-evaled because vue may be required before 10511// vue-server-renderer can set VUE_ENV 10512var _isServer; 10513var isServerRendering = function () { 10514 if (_isServer === undefined) { 10515 /* istanbul ignore if */ 10516 if (!inBrowser && typeof global !== 'undefined') { 10517 // detect presence of vue-server-renderer and avoid 10518 // Webpack shimming the process 10519 _isServer = global['process'].env.VUE_ENV === 'server'; 10520 } else { 10521 _isServer = false; 10522 } 10523 } 10524 return _isServer 10525}; 10526 10527// detect devtools 10528var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; 10529 10530/* istanbul ignore next */ 10531function isNative (Ctor) { 10532 return typeof Ctor === 'function' && /native code/.test(Ctor.toString()) 10533} 10534 10535var hasSymbol = 10536 typeof Symbol !== 'undefined' && isNative(Symbol) && 10537 typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); 10538 10539var _Set; 10540/* istanbul ignore if */ // $flow-disable-line 10541if (typeof Set !== 'undefined' && isNative(Set)) { 10542 // use native Set when available. 10543 _Set = Set; 10544} else { 10545 // a non-standard Set polyfill that only works with primitive keys. 10546 _Set = (function () { 10547 function Set () { 10548 this.set = Object.create(null); 10549 } 10550 Set.prototype.has = function has (key) { 10551 return this.set[key] === true 10552 }; 10553 Set.prototype.add = function add (key) { 10554 this.set[key] = true; 10555 }; 10556 Set.prototype.clear = function clear () { 10557 this.set = Object.create(null); 10558 }; 10559 10560 return Set; 10561 }()); 10562} 10563 10564/* */ 10565 10566var warn = noop; 10567var tip = noop; 10568var generateComponentTrace = (noop); // work around flow check 10569var formatComponentName = (noop); 10570 10571if (process.env.NODE_ENV !== 'production') { 10572 var hasConsole = typeof console !== 'undefined'; 10573 var classifyRE = /(?:^|[-_])(\w)/g; 10574 var classify = function (str) { return str 10575 .replace(classifyRE, function (c) { return c.toUpperCase(); }) 10576 .replace(/[-_]/g, ''); }; 10577 10578 warn = function (msg, vm) { 10579 var trace = vm ? generateComponentTrace(vm) : ''; 10580 10581 if (config.warnHandler) { 10582 config.warnHandler.call(null, msg, vm, trace); 10583 } else if (hasConsole && (!config.silent)) { 10584 console.error(("[Vue warn]: " + msg + trace)); 10585 } 10586 }; 10587 10588 tip = function (msg, vm) { 10589 if (hasConsole && (!config.silent)) { 10590 console.warn("[Vue tip]: " + msg + ( 10591 vm ? generateComponentTrace(vm) : '' 10592 )); 10593 } 10594 }; 10595 10596 formatComponentName = function (vm, includeFile) { 10597 if (vm.$root === vm) { 10598 return '<Root>' 10599 } 10600 var options = typeof vm === 'function' && vm.cid != null 10601 ? vm.options 10602 : vm._isVue 10603 ? vm.$options || vm.constructor.options 10604 : vm || {}; 10605 var name = options.name || options._componentTag; 10606 var file = options.__file; 10607 if (!name && file) { 10608 var match = file.match(/([^/\\]+)\.vue$/); 10609 name = match && match[1]; 10610 } 10611 10612 return ( 10613 (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") + 10614 (file && includeFile !== false ? (" at " + file) : '') 10615 ) 10616 }; 10617 10618 var repeat = function (str, n) { 10619 var res = ''; 10620 while (n) { 10621 if (n % 2 === 1) { res += str; } 10622 if (n > 1) { str += str; } 10623 n >>= 1; 10624 } 10625 return res 10626 }; 10627 10628 generateComponentTrace = function (vm) { 10629 if (vm._isVue && vm.$parent) { 10630 var tree = []; 10631 var currentRecursiveSequence = 0; 10632 while (vm) { 10633 if (tree.length > 0) { 10634 var last = tree[tree.length - 1]; 10635 if (last.constructor === vm.constructor) { 10636 currentRecursiveSequence++; 10637 vm = vm.$parent; 10638 continue 10639 } else if (currentRecursiveSequence > 0) { 10640 tree[tree.length - 1] = [last, currentRecursiveSequence]; 10641 currentRecursiveSequence = 0; 10642 } 10643 } 10644 tree.push(vm); 10645 vm = vm.$parent; 10646 } 10647 return '\n\nfound in\n\n' + tree 10648 .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm) 10649 ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)") 10650 : formatComponentName(vm))); }) 10651 .join('\n') 10652 } else { 10653 return ("\n\n(found in " + (formatComponentName(vm)) + ")") 10654 } 10655 }; 10656} 10657 10658/* */ 10659 10660 10661var uid = 0; 10662 10663/** 10664 * A dep is an observable that can have multiple 10665 * directives subscribing to it. 10666 */ 10667var Dep = function Dep () { 10668 this.id = uid++; 10669 this.subs = []; 10670}; 10671 10672Dep.prototype.addSub = function addSub (sub) { 10673 this.subs.push(sub); 10674}; 10675 10676Dep.prototype.removeSub = function removeSub (sub) { 10677 remove(this.subs, sub); 10678}; 10679 10680Dep.prototype.depend = function depend () { 10681 if (Dep.target) { 10682 Dep.target.addDep(this); 10683 } 10684}; 10685 10686Dep.prototype.notify = function notify () { 10687 // stabilize the subscriber list first 10688 var subs = this.subs.slice(); 10689 for (var i = 0, l = subs.length; i < l; i++) { 10690 subs[i].update(); 10691 } 10692}; 10693 10694// the current target watcher being evaluated. 10695// this is globally unique because there could be only one 10696// watcher being evaluated at any time. 10697Dep.target = null; 10698var targetStack = []; 10699 10700function pushTarget (_target) { 10701 if (Dep.target) { targetStack.push(Dep.target); } 10702 Dep.target = _target; 10703} 10704 10705function popTarget () { 10706 Dep.target = targetStack.pop(); 10707} 10708 10709/* */ 10710 10711var VNode = function VNode ( 10712 tag, 10713 data, 10714 children, 10715 text, 10716 elm, 10717 context, 10718 componentOptions, 10719 asyncFactory 10720) { 10721 this.tag = tag; 10722 this.data = data; 10723 this.children = children; 10724 this.text = text; 10725 this.elm = elm; 10726 this.ns = undefined; 10727 this.context = context; 10728 this.functionalContext = undefined; 10729 this.functionalOptions = undefined; 10730 this.functionalScopeId = undefined; 10731 this.key = data && data.key; 10732 this.componentOptions = componentOptions; 10733 this.componentInstance = undefined; 10734 this.parent = undefined; 10735 this.raw = false; 10736 this.isStatic = false; 10737 this.isRootInsert = true; 10738 this.isComment = false; 10739 this.isCloned = false; 10740 this.isOnce = false; 10741 this.asyncFactory = asyncFactory; 10742 this.asyncMeta = undefined; 10743 this.isAsyncPlaceholder = false; 10744}; 10745 10746var prototypeAccessors = { child: { configurable: true } }; 10747 10748// DEPRECATED: alias for componentInstance for backwards compat. 10749/* istanbul ignore next */ 10750prototypeAccessors.child.get = function () { 10751 return this.componentInstance 10752}; 10753 10754Object.defineProperties( VNode.prototype, prototypeAccessors ); 10755 10756var createEmptyVNode = function (text) { 10757 if ( text === void 0 ) text = ''; 10758 10759 var node = new VNode(); 10760 node.text = text; 10761 node.isComment = true; 10762 return node 10763}; 10764 10765function createTextVNode (val) { 10766 return new VNode(undefined, undefined, undefined, String(val)) 10767} 10768 10769// optimized shallow clone 10770// used for static nodes and slot nodes because they may be reused across 10771// multiple renders, cloning them avoids errors when DOM manipulations rely 10772// on their elm reference. 10773function cloneVNode (vnode, deep) { 10774 var componentOptions = vnode.componentOptions; 10775 var cloned = new VNode( 10776 vnode.tag, 10777 vnode.data, 10778 vnode.children, 10779 vnode.text, 10780 vnode.elm, 10781 vnode.context, 10782 componentOptions, 10783 vnode.asyncFactory 10784 ); 10785 cloned.ns = vnode.ns; 10786 cloned.isStatic = vnode.isStatic; 10787 cloned.key = vnode.key; 10788 cloned.isComment = vnode.isComment; 10789 cloned.isCloned = true; 10790 if (deep) { 10791 if (vnode.children) { 10792 cloned.children = cloneVNodes(vnode.children, true); 10793 } 10794 if (componentOptions && componentOptions.children) { 10795 componentOptions.children = cloneVNodes(componentOptions.children, true); 10796 } 10797 } 10798 return cloned 10799} 10800 10801function cloneVNodes (vnodes, deep) { 10802 var len = vnodes.length; 10803 var res = new Array(len); 10804 for (var i = 0; i < len; i++) { 10805 res[i] = cloneVNode(vnodes[i], deep); 10806 } 10807 return res 10808} 10809 10810/* 10811 * not type checking this file because flow doesn't play well with 10812 * dynamically accessing methods on Array prototype 10813 */ 10814 10815var arrayProto = Array.prototype; 10816var arrayMethods = Object.create(arrayProto);[ 10817 'push', 10818 'pop', 10819 'shift', 10820 'unshift', 10821 'splice', 10822 'sort', 10823 'reverse' 10824] 10825.forEach(function (method) { 10826 // cache original method 10827 var original = arrayProto[method]; 10828 def(arrayMethods, method, function mutator () { 10829 var args = [], len = arguments.length; 10830 while ( len-- ) args[ len ] = arguments[ len ]; 10831 10832 var result = original.apply(this, args); 10833 var ob = this.__ob__; 10834 var inserted; 10835 switch (method) { 10836 case 'push': 10837 case 'unshift': 10838 inserted = args; 10839 break 10840 case 'splice': 10841 inserted = args.slice(2); 10842 break 10843 } 10844 if (inserted) { ob.observeArray(inserted); } 10845 // notify change 10846 ob.dep.notify(); 10847 return result 10848 }); 10849}); 10850 10851/* */ 10852 10853var arrayKeys = Object.getOwnPropertyNames(arrayMethods); 10854 10855/** 10856 * By default, when a reactive property is set, the new value is 10857 * also converted to become reactive. However when passing down props, 10858 * we don't want to force conversion because the value may be a nested value 10859 * under a frozen data structure. Converting it would defeat the optimization. 10860 */ 10861var observerState = { 10862 shouldConvert: true 10863}; 10864 10865/** 10866 * Observer class that are attached to each observed 10867 * object. Once attached, the observer converts target 10868 * object's property keys into getter/setters that 10869 * collect dependencies and dispatches updates. 10870 */ 10871var Observer = function Observer (value) { 10872 this.value = value; 10873 this.dep = new Dep(); 10874 this.vmCount = 0; 10875 def(value, '__ob__', this); 10876 if (Array.isArray(value)) { 10877 var augment = hasProto 10878 ? protoAugment 10879 : copyAugment; 10880 augment(value, arrayMethods, arrayKeys); 10881 this.observeArray(value); 10882 } else { 10883 this.walk(value); 10884 } 10885}; 10886 10887/** 10888 * Walk through each property and convert them into 10889 * getter/setters. This method should only be called when 10890 * value type is Object. 10891 */ 10892Observer.prototype.walk = function walk (obj) { 10893 var keys = Object.keys(obj); 10894 for (var i = 0; i < keys.length; i++) { 10895 defineReactive(obj, keys[i], obj[keys[i]]); 10896 } 10897}; 10898 10899/** 10900 * Observe a list of Array items. 10901 */ 10902Observer.prototype.observeArray = function observeArray (items) { 10903 for (var i = 0, l = items.length; i < l; i++) { 10904 observe(items[i]); 10905 } 10906}; 10907 10908// helpers 10909 10910/** 10911 * Augment an target Object or Array by intercepting 10912 * the prototype chain using __proto__ 10913 */ 10914function protoAugment (target, src, keys) { 10915 /* eslint-disable no-proto */ 10916 target.__proto__ = src; 10917 /* eslint-enable no-proto */ 10918} 10919 10920/** 10921 * Augment an target Object or Array by defining 10922 * hidden properties. 10923 */ 10924/* istanbul ignore next */ 10925function copyAugment (target, src, keys) { 10926 for (var i = 0, l = keys.length; i < l; i++) { 10927 var key = keys[i]; 10928 def(target, key, src[key]); 10929 } 10930} 10931 10932/** 10933 * Attempt to create an observer instance for a value, 10934 * returns the new observer if successfully observed, 10935 * or the existing observer if the value already has one. 10936 */ 10937function observe (value, asRootData) { 10938 if (!isObject(value) || value instanceof VNode) { 10939 return 10940 } 10941 var ob; 10942 if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { 10943 ob = value.__ob__; 10944 } else if ( 10945 observerState.shouldConvert && 10946 !isServerRendering() && 10947 (Array.isArray(value) || isPlainObject(value)) && 10948 Object.isExtensible(value) && 10949 !value._isVue 10950 ) { 10951 ob = new Observer(value); 10952 } 10953 if (asRootData && ob) { 10954 ob.vmCount++; 10955 } 10956 return ob 10957} 10958 10959/** 10960 * Define a reactive property on an Object. 10961 */ 10962function defineReactive ( 10963 obj, 10964 key, 10965 val, 10966 customSetter, 10967 shallow 10968) { 10969 var dep = new Dep(); 10970 10971 var property = Object.getOwnPropertyDescriptor(obj, key); 10972 if (property && property.configurable === false) { 10973 return 10974 } 10975 10976 // cater for pre-defined getter/setters 10977 var getter = property && property.get; 10978 var setter = property && property.set; 10979 10980 var childOb = !shallow && observe(val); 10981 Object.defineProperty(obj, key, { 10982 enumerable: true, 10983 configurable: true, 10984 get: function reactiveGetter () { 10985 var value = getter ? getter.call(obj) : val; 10986 if (Dep.target) { 10987 dep.depend(); 10988 if (childOb) { 10989 childOb.dep.depend(); 10990 if (Array.isArray(value)) { 10991 dependArray(value); 10992 } 10993 } 10994 } 10995 return value 10996 }, 10997 set: function reactiveSetter (newVal) { 10998 var value = getter ? getter.call(obj) : val; 10999 /* eslint-disable no-self-compare */ 11000 if (newVal === value || (newVal !== newVal && value !== value)) { 11001 return 11002 } 11003 /* eslint-enable no-self-compare */ 11004 if (process.env.NODE_ENV !== 'production' && customSetter) { 11005 customSetter(); 11006 } 11007 if (setter) { 11008 setter.call(obj, newVal); 11009 } else { 11010 val = newVal; 11011 } 11012 childOb = !shallow && observe(newVal); 11013 dep.notify(); 11014 } 11015 }); 11016} 11017 11018/** 11019 * Set a property on an object. Adds the new property and 11020 * triggers change notification if the property doesn't 11021 * already exist. 11022 */ 11023function set (target, key, val) { 11024 if (Array.isArray(target) && isValidArrayIndex(key)) { 11025 target.length = Math.max(target.length, key); 11026 target.splice(key, 1, val); 11027 return val 11028 } 11029 if (key in target && !(key in Object.prototype)) { 11030 target[key] = val; 11031 return val 11032 } 11033 var ob = (target).__ob__; 11034 if (target._isVue || (ob && ob.vmCount)) { 11035 process.env.NODE_ENV !== 'production' && warn( 11036 'Avoid adding reactive properties to a Vue instance or its root $data ' + 11037 'at runtime - declare it upfront in the data option.' 11038 ); 11039 return val 11040 } 11041 if (!ob) { 11042 target[key] = val; 11043 return val 11044 } 11045 defineReactive(ob.value, key, val); 11046 ob.dep.notify(); 11047 return val 11048} 11049 11050/** 11051 * Delete a property and trigger change if necessary. 11052 */ 11053function del (target, key) { 11054 if (Array.isArray(target) && isValidArrayIndex(key)) { 11055 target.splice(key, 1); 11056 return 11057 } 11058 var ob = (target).__ob__; 11059 if (target._isVue || (ob && ob.vmCount)) { 11060 process.env.NODE_ENV !== 'production' && warn( 11061 'Avoid deleting properties on a Vue instance or its root $data ' + 11062 '- just set it to null.' 11063 ); 11064 return 11065 } 11066 if (!hasOwn(target, key)) { 11067 return 11068 } 11069 delete target[key]; 11070 if (!ob) { 11071 return 11072 } 11073 ob.dep.notify(); 11074} 11075 11076/** 11077 * Collect dependencies on array elements when the array is touched, since 11078 * we cannot intercept array element access like property getters. 11079 */ 11080function dependArray (value) { 11081 for (var e = (void 0), i = 0, l = value.length; i < l; i++) { 11082 e = value[i]; 11083 e && e.__ob__ && e.__ob__.dep.depend(); 11084 if (Array.isArray(e)) { 11085 dependArray(e); 11086 } 11087 } 11088} 11089 11090/* */ 11091 11092/** 11093 * Option overwriting strategies are functions that handle 11094 * how to merge a parent option value and a child option 11095 * value into the final value. 11096 */ 11097var strats = config.optionMergeStrategies; 11098 11099/** 11100 * Options with restrictions 11101 */ 11102if (process.env.NODE_ENV !== 'production') { 11103 strats.el = strats.propsData = function (parent, child, vm, key) { 11104 if (!vm) { 11105 warn( 11106 "option \"" + key + "\" can only be used during instance " + 11107 'creation with the `new` keyword.' 11108 ); 11109 } 11110 return defaultStrat(parent, child) 11111 }; 11112} 11113 11114/** 11115 * Helper that recursively merges two data objects together. 11116 */ 11117function mergeData (to, from) { 11118 if (!from) { return to } 11119 var key, toVal, fromVal; 11120 var keys = Object.keys(from); 11121 for (var i = 0; i < keys.length; i++) { 11122 key = keys[i]; 11123 toVal = to[key]; 11124 fromVal = from[key]; 11125 if (!hasOwn(to, key)) { 11126 set(to, key, fromVal); 11127 } else if (isPlainObject(toVal) && isPlainObject(fromVal)) { 11128 mergeData(toVal, fromVal); 11129 } 11130 } 11131 return to 11132} 11133 11134/** 11135 * Data 11136 */ 11137function mergeDataOrFn ( 11138 parentVal, 11139 childVal, 11140 vm 11141) { 11142 if (!vm) { 11143 // in a Vue.extend merge, both should be functions 11144 if (!childVal) { 11145 return parentVal 11146 } 11147 if (!parentVal) { 11148 return childVal 11149 } 11150 // when parentVal & childVal are both present, 11151 // we need to return a function that returns the 11152 // merged result of both functions... no need to 11153 // check if parentVal is a function here because 11154 // it has to be a function to pass previous merges. 11155 return function mergedDataFn () { 11156 return mergeData( 11157 typeof childVal === 'function' ? childVal.call(this) : childVal, 11158 typeof parentVal === 'function' ? parentVal.call(this) : parentVal 11159 ) 11160 } 11161 } else { 11162 return function mergedInstanceDataFn () { 11163 // instance merge 11164 var instanceData = typeof childVal === 'function' 11165 ? childVal.call(vm) 11166 : childVal; 11167 var defaultData = typeof parentVal === 'function' 11168 ? parentVal.call(vm) 11169 : parentVal; 11170 if (instanceData) { 11171 return mergeData(instanceData, defaultData) 11172 } else { 11173 return defaultData 11174 } 11175 } 11176 } 11177} 11178 11179strats.data = function ( 11180 parentVal, 11181 childVal, 11182 vm 11183) { 11184 if (!vm) { 11185 if (childVal && typeof childVal !== 'function') { 11186 process.env.NODE_ENV !== 'production' && warn( 11187 'The "data" option should be a function ' + 11188 'that returns a per-instance value in component ' + 11189 'definitions.', 11190 vm 11191 ); 11192 11193 return parentVal 11194 } 11195 return mergeDataOrFn(parentVal, childVal) 11196 } 11197 11198 return mergeDataOrFn(parentVal, childVal, vm) 11199}; 11200 11201/** 11202 * Hooks and props are merged as arrays. 11203 */ 11204function mergeHook ( 11205 parentVal, 11206 childVal 11207) { 11208 return childVal 11209 ? parentVal 11210 ? parentVal.concat(childVal) 11211 : Array.isArray(childVal) 11212 ? childVal 11213 : [childVal] 11214 : parentVal 11215} 11216 11217LIFECYCLE_HOOKS.forEach(function (hook) { 11218 strats[hook] = mergeHook; 11219}); 11220 11221/** 11222 * Assets 11223 * 11224 * When a vm is present (instance creation), we need to do 11225 * a three-way merge between constructor options, instance 11226 * options and parent options. 11227 */ 11228function mergeAssets ( 11229 parentVal, 11230 childVal, 11231 vm, 11232 key 11233) { 11234 var res = Object.create(parentVal || null); 11235 if (childVal) { 11236 process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm); 11237 return extend(res, childVal) 11238 } else { 11239 return res 11240 } 11241} 11242 11243ASSET_TYPES.forEach(function (type) { 11244 strats[type + 's'] = mergeAssets; 11245}); 11246 11247/** 11248 * Watchers. 11249 * 11250 * Watchers hashes should not overwrite one 11251 * another, so we merge them as arrays. 11252 */ 11253strats.watch = function ( 11254 parentVal, 11255 childVal, 11256 vm, 11257 key 11258) { 11259 // work around Firefox's Object.prototype.watch... 11260 if (parentVal === nativeWatch) { parentVal = undefined; } 11261 if (childVal === nativeWatch) { childVal = undefined; } 11262 /* istanbul ignore if */ 11263 if (!childVal) { return Object.create(parentVal || null) } 11264 if (process.env.NODE_ENV !== 'production') { 11265 assertObjectType(key, childVal, vm); 11266 } 11267 if (!parentVal) { return childVal } 11268 var ret = {}; 11269 extend(ret, parentVal); 11270 for (var key$1 in childVal) { 11271 var parent = ret[key$1]; 11272 var child = childVal[key$1]; 11273 if (parent && !Array.isArray(parent)) { 11274 parent = [parent]; 11275 } 11276 ret[key$1] = parent 11277 ? parent.concat(child) 11278 : Array.isArray(child) ? child : [child]; 11279 } 11280 return ret 11281}; 11282 11283/** 11284 * Other object hashes. 11285 */ 11286strats.props = 11287strats.methods = 11288strats.inject = 11289strats.computed = function ( 11290 parentVal, 11291 childVal, 11292 vm, 11293 key 11294) { 11295 if (childVal && process.env.NODE_ENV !== 'production') { 11296 assertObjectType(key, childVal, vm); 11297 } 11298 if (!parentVal) { return childVal } 11299 var ret = Object.create(null); 11300 extend(ret, parentVal); 11301 if (childVal) { extend(ret, childVal); } 11302 return ret 11303}; 11304strats.provide = mergeDataOrFn; 11305 11306/** 11307 * Default strategy. 11308 */ 11309var defaultStrat = function (parentVal, childVal) { 11310 return childVal === undefined 11311 ? parentVal 11312 : childVal 11313}; 11314 11315/** 11316 * Validate component names 11317 */ 11318function checkComponents (options) { 11319 for (var key in options.components) { 11320 var lower = key.toLowerCase(); 11321 if (isBuiltInTag(lower) || config.isReservedTag(lower)) { 11322 warn( 11323 'Do not use built-in or reserved HTML elements as component ' + 11324 'id: ' + key 11325 ); 11326 } 11327 } 11328} 11329 11330/** 11331 * Ensure all props option syntax are normalized into the 11332 * Object-based format. 11333 */ 11334function normalizeProps (options, vm) { 11335 var props = options.props; 11336 if (!props) { return } 11337 var res = {}; 11338 var i, val, name; 11339 if (Array.isArray(props)) { 11340 i = props.length; 11341 while (i--) { 11342 val = props[i]; 11343 if (typeof val === 'string') { 11344 name = camelize(val); 11345 res[name] = { type: null }; 11346 } else if (process.env.NODE_ENV !== 'production') { 11347 warn('props must be strings when using array syntax.'); 11348 } 11349 } 11350 } else if (isPlainObject(props)) { 11351 for (var key in props) { 11352 val = props[key]; 11353 name = camelize(key); 11354 res[name] = isPlainObject(val) 11355 ? val 11356 : { type: val }; 11357 } 11358 } else if (process.env.NODE_ENV !== 'production') { 11359 warn( 11360 "Invalid value for option \"props\": expected an Array or an Object, " + 11361 "but got " + (toRawType(props)) + ".", 11362 vm 11363 ); 11364 } 11365 options.props = res; 11366} 11367 11368/** 11369 * Normalize all injections into Object-based format 11370 */ 11371function normalizeInject (options, vm) { 11372 var inject = options.inject; 11373 var normalized = options.inject = {}; 11374 if (Array.isArray(inject)) { 11375 for (var i = 0; i < inject.length; i++) { 11376 normalized[inject[i]] = { from: inject[i] }; 11377 } 11378 } else if (isPlainObject(inject)) { 11379 for (var key in inject) { 11380 var val = inject[key]; 11381 normalized[key] = isPlainObject(val) 11382 ? extend({ from: key }, val) 11383 : { from: val }; 11384 } 11385 } else if (process.env.NODE_ENV !== 'production' && inject) { 11386 warn( 11387 "Invalid value for option \"inject\": expected an Array or an Object, " + 11388 "but got " + (toRawType(inject)) + ".", 11389 vm 11390 ); 11391 } 11392} 11393 11394/** 11395 * Normalize raw function directives into object format. 11396 */ 11397function normalizeDirectives (options) { 11398 var dirs = options.directives; 11399 if (dirs) { 11400 for (var key in dirs) { 11401 var def = dirs[key]; 11402 if (typeof def === 'function') { 11403 dirs[key] = { bind: def, update: def }; 11404 } 11405 } 11406 } 11407} 11408 11409function assertObjectType (name, value, vm) { 11410 if (!isPlainObject(value)) { 11411 warn( 11412 "Invalid value for option \"" + name + "\": expected an Object, " + 11413 "but got " + (toRawType(value)) + ".", 11414 vm 11415 ); 11416 } 11417} 11418 11419/** 11420 * Merge two option objects into a new one. 11421 * Core utility used in both instantiation and inheritance. 11422 */ 11423function mergeOptions ( 11424 parent, 11425 child, 11426 vm 11427) { 11428 if (process.env.NODE_ENV !== 'production') { 11429 checkComponents(child); 11430 } 11431 11432 if (typeof child === 'function') { 11433 child = child.options; 11434 } 11435 11436 normalizeProps(child, vm); 11437 normalizeInject(child, vm); 11438 normalizeDirectives(child); 11439 var extendsFrom = child.extends; 11440 if (extendsFrom) { 11441 parent = mergeOptions(parent, extendsFrom, vm); 11442 } 11443 if (child.mixins) { 11444 for (var i = 0, l = child.mixins.length; i < l; i++) { 11445 parent = mergeOptions(parent, child.mixins[i], vm); 11446 } 11447 } 11448 var options = {}; 11449 var key; 11450 for (key in parent) { 11451 mergeField(key); 11452 } 11453 for (key in child) { 11454 if (!hasOwn(parent, key)) { 11455 mergeField(key); 11456 } 11457 } 11458 function mergeField (key) { 11459 var strat = strats[key] || defaultStrat; 11460 options[key] = strat(parent[key], child[key], vm, key); 11461 } 11462 return options 11463} 11464 11465/** 11466 * Resolve an asset. 11467 * This function is used because child instances need access 11468 * to assets defined in its ancestor chain. 11469 */ 11470function resolveAsset ( 11471 options, 11472 type, 11473 id, 11474 warnMissing 11475) { 11476 /* istanbul ignore if */ 11477 if (typeof id !== 'string') { 11478 return 11479 } 11480 var assets = options[type]; 11481 // check local registration variations first 11482 if (hasOwn(assets, id)) { return assets[id] } 11483 var camelizedId = camelize(id); 11484 if (hasOwn(assets, camelizedId)) { return assets[camelizedId] } 11485 var PascalCaseId = capitalize(camelizedId); 11486 if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] } 11487 // fallback to prototype chain 11488 var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; 11489 if (process.env.NODE_ENV !== 'production' && warnMissing && !res) { 11490 warn( 11491 'Failed to resolve ' + type.slice(0, -1) + ': ' + id, 11492 options 11493 ); 11494 } 11495 return res 11496} 11497 11498/* */ 11499 11500function validateProp ( 11501 key, 11502 propOptions, 11503 propsData, 11504 vm 11505) { 11506 var prop = propOptions[key]; 11507 var absent = !hasOwn(propsData, key); 11508 var value = propsData[key]; 11509 // handle boolean props 11510 if (isType(Boolean, prop.type)) { 11511 if (absent && !hasOwn(prop, 'default')) { 11512 value = false; 11513 } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) { 11514 value = true; 11515 } 11516 } 11517 // check default value 11518 if (value === undefined) { 11519 value = getPropDefaultValue(vm, prop, key); 11520 // since the default value is a fresh copy, 11521 // make sure to observe it. 11522 var prevShouldConvert = observerState.shouldConvert; 11523 observerState.shouldConvert = true; 11524 observe(value); 11525 observerState.shouldConvert = prevShouldConvert; 11526 } 11527 if (process.env.NODE_ENV !== 'production') { 11528 assertProp(prop, key, value, vm, absent); 11529 } 11530 return value 11531} 11532 11533/** 11534 * Get the default value of a prop. 11535 */ 11536function getPropDefaultValue (vm, prop, key) { 11537 // no default, return undefined 11538 if (!hasOwn(prop, 'default')) { 11539 return undefined 11540 } 11541 var def = prop.default; 11542 // warn against non-factory defaults for Object & Array 11543 if (process.env.NODE_ENV !== 'production' && isObject(def)) { 11544 warn( 11545 'Invalid default value for prop "' + key + '": ' + 11546 'Props with type Object/Array must use a factory function ' + 11547 'to return the default value.', 11548 vm 11549 ); 11550 } 11551 // the raw prop value was also undefined from previous render, 11552 // return previous default value to avoid unnecessary watcher trigger 11553 if (vm && vm.$options.propsData && 11554 vm.$options.propsData[key] === undefined && 11555 vm._props[key] !== undefined 11556 ) { 11557 return vm._props[key] 11558 } 11559 // call factory function for non-Function types 11560 // a value is Function if its prototype is function even across different execution context 11561 return typeof def === 'function' && getType(prop.type) !== 'Function' 11562 ? def.call(vm) 11563 : def 11564} 11565 11566/** 11567 * Assert whether a prop is valid. 11568 */ 11569function assertProp ( 11570 prop, 11571 name, 11572 value, 11573 vm, 11574 absent 11575) { 11576 if (prop.required && absent) { 11577 warn( 11578 'Missing required prop: "' + name + '"', 11579 vm 11580 ); 11581 return 11582 } 11583 if (value == null && !prop.required) { 11584 return 11585 } 11586 var type = prop.type; 11587 var valid = !type || type === true; 11588 var expectedTypes = []; 11589 if (type) { 11590 if (!Array.isArray(type)) { 11591 type = [type]; 11592 } 11593 for (var i = 0; i < type.length && !valid; i++) { 11594 var assertedType = assertType(value, type[i]); 11595 expectedTypes.push(assertedType.expectedType || ''); 11596 valid = assertedType.valid; 11597 } 11598 } 11599 if (!valid) { 11600 warn( 11601 "Invalid prop: type check failed for prop \"" + name + "\"." + 11602 " Expected " + (expectedTypes.map(capitalize).join(', ')) + 11603 ", got " + (toRawType(value)) + ".", 11604 vm 11605 ); 11606 return 11607 }
11608 var validator = prop.validator; 11609 if (validator) { 11610 if (!validator(value)) { 11611 warn( 11612 'Invalid prop: custom validator check failed for prop "' + name + '".', 11613 vm 11614 ); 11615 } 11616 } 11617} 11618 11619var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/; 11620 11621function assertType (value, type) { 11622 var valid; 11623 var expectedType = getType(type); 11624 if (simpleCheckRE.test(expectedType)) { 11625 var t = typeof value; 11626 valid = t === expectedType.toLowerCase(); 11627 // for primitive wrapper objects 11628 if (!valid && t === 'object') { 11629 valid = value instanceof type; 11630 } 11631 } else if (expectedType === 'Object') { 11632 valid = isPlainObject(value); 11633 } else if (expectedType === 'Array') { 11634 valid = Array.isArray(value); 11635 } else { 11636 valid = value instanceof type; 11637 } 11638 return { 11639 valid: valid, 11640 expectedType: expectedType 11641 } 11642} 11643 11644/** 11645 * Use function string name to check built-in types, 11646 * because a simple equality check will fail when running 11647 * across different vms / iframes. 11648 */ 11649function getType (fn) { 11650 var match = fn && fn.toString().match(/^\s*function (\w+)/); 11651 return match ? match[1] : '' 11652} 11653 11654function isType (type, fn) { 11655 if (!Array.isArray(fn)) { 11656 return getType(fn) === getType(type) 11657 } 11658 for (var i = 0, len = fn.length; i < len; i++) { 11659 if (getType(fn[i]) === getType(type)) { 11660 return true 11661 } 11662 } 11663 /* istanbul ignore next */ 11664 return false 11665} 11666 11667/* */ 11668 11669function handleError (err, vm, info) { 11670 if (vm) { 11671 var cur = vm; 11672 while ((cur = cur.$parent)) { 11673 var hooks = cur.$options.errorCaptured; 11674 if (hooks) { 11675 for (var i = 0; i < hooks.length; i++) { 11676 try { 11677 var capture = hooks[i].call(cur, err, vm, info) === false; 11678 if (capture) { return } 11679 } catch (e) { 11680 globalHandleError(e, cur, 'errorCaptured hook'); 11681 } 11682 } 11683 } 11684 } 11685 } 11686 globalHandleError(err, vm, info); 11687} 11688 11689function globalHandleError (err, vm, info) { 11690 if (config.errorHandler) { 11691 try { 11692 return config.errorHandler.call(null, err, vm, info) 11693 } catch (e) { 11694 logError(e, null, 'config.errorHandler'); 11695 } 11696 } 11697 logError(err, vm, info); 11698} 11699 11700function logError (err, vm, info) { 11701 if (process.env.NODE_ENV !== 'production') { 11702 warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm); 11703 } 11704 /* istanbul ignore else */ 11705 if ((inBrowser || inWeex) && typeof console !== 'undefined') { 11706 console.error(err); 11707 } else { 11708 throw err 11709 } 11710} 11711 11712/* */ 11713/* globals MessageChannel */ 11714 11715var callbacks = []; 11716var pending = false; 11717 11718function flushCallbacks () { 11719 pending = false; 11720 var copies = callbacks.slice(0); 11721 callbacks.length = 0; 11722 for (var i = 0; i < copies.length; i++) { 11723 copies[i](); 11724 } 11725} 11726 11727// Here we have async deferring wrappers using both micro and macro tasks. 11728// In < 2.4 we used micro tasks everywhere, but there are some scenarios where 11729// micro tasks have too high a priority and fires in between supposedly 11730// sequential events (e.g. #4521, #6690) or even between bubbling of the same 11731// event (#6566). However, using macro tasks everywhere also has subtle problems 11732// when state is changed right before repaint (e.g. #6813, out-in transitions). 11733// Here we use micro task by default, but expose a way to force macro task when 11734// needed (e.g. in event handlers attached by v-on). 11735var microTimerFunc; 11736var macroTimerFunc; 11737var useMacroTask = false; 11738 11739// Determine (macro) Task defer implementation. 11740// Technically setImmediate should be the ideal choice, but it's only available 11741// in IE. The only polyfill that consistently queues the callback after all DOM 11742// events triggered in the same loop is by using MessageChannel. 11743/* istanbul ignore if */ 11744if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { 11745 macroTimerFunc = function () { 11746 setImmediate(flushCallbacks); 11747 }; 11748} else if (typeof MessageChannel !== 'undefined' && ( 11749 isNative(MessageChannel) || 11750 // PhantomJS 11751 MessageChannel.toString() === '[object MessageChannelConstructor]' 11752)) { 11753 var channel = new MessageChannel(); 11754 var port = channel.port2; 11755 channel.port1.onmessage = flushCallbacks;
vendor: 9,185 bytes, lines 11756-12119
11756 macroTimerFunc = function () { 11757 port.postMessage(1); 11758 }; 11759} else { 11760 /* istanbul ignore next */ 11761 macroTimerFunc = function () { 11762 setTimeout(flushCallbacks, 0); 11763 }; 11764} 11765 11766// Determine MicroTask defer implementation. 11767/* istanbul ignore next, $flow-disable-line */ 11768if (typeof Promise !== 'undefined' && isNative(Promise)) { 11769 var p = Promise.resolve(); 11770 microTimerFunc = function () { 11771 p.then(flushCallbacks); 11772 // in problematic UIWebViews, Promise.then doesn't completely break, but 11773 // it can get stuck in a weird state where callbacks are pushed into the 11774 // microtask queue but the queue isn't being flushed, until the browser 11775 // needs to do some other work, e.g. handle a timer. Therefore we can 11776 // "force" the microtask queue to be flushed by adding an empty timer. 11777 if (isIOS) { setTimeout(noop); } 11778 }; 11779} else { 11780 // fallback to macro 11781 microTimerFunc = macroTimerFunc; 11782} 11783 11784/** 11785 * Wrap a function so that if any code inside triggers state change, 11786 * the changes are queued using a Task instead of a MicroTask. 11787 */ 11788function withMacroTask (fn) { 11789 return fn._withTask || (fn._withTask = function () { 11790 useMacroTask = true; 11791 var res = fn.apply(null, arguments); 11792 useMacroTask = false; 11793 return res 11794 }) 11795} 11796 11797function nextTick (cb, ctx) { 11798 var _resolve; 11799 callbacks.push(function () { 11800 if (cb) { 11801 try { 11802 cb.call(ctx); 11803 } catch (e) { 11804 handleError(e, ctx, 'nextTick'); 11805 } 11806 } else if (_resolve) { 11807 _resolve(ctx); 11808 } 11809 }); 11810 if (!pending) { 11811 pending = true; 11812 if (useMacroTask) { 11813 macroTimerFunc(); 11814 } else { 11815 microTimerFunc(); 11816 } 11817 } 11818 // $flow-disable-line 11819 if (!cb && typeof Promise !== 'undefined') { 11820 return new Promise(function (resolve) { 11821 _resolve = resolve; 11822 }) 11823 } 11824} 11825 11826/* */ 11827 11828var mark; 11829var measure; 11830 11831if (process.env.NODE_ENV !== 'production') { 11832 var perf = inBrowser && window.performance; 11833 /* istanbul ignore if */ 11834 if ( 11835 perf && 11836 perf.mark && 11837 perf.measure && 11838 perf.clearMarks && 11839 perf.clearMeasures 11840 ) { 11841 mark = function (tag) { return perf.mark(tag); }; 11842 measure = function (name, startTag, endTag) { 11843 perf.measure(name, startTag, endTag); 11844 perf.clearMarks(startTag); 11845 perf.clearMarks(endTag); 11846 perf.clearMeasures(name); 11847 }; 11848 } 11849} 11850 11851/* not type checking this file because flow doesn't play well with Proxy */ 11852 11853var initProxy; 11854 11855if (process.env.NODE_ENV !== 'production') { 11856 var allowedGlobals = makeMap( 11857 'Infinity,undefined,NaN,isFinite,isNaN,' + 11858 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 11859 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + 11860 'require' // for Webpack/Browserify 11861 ); 11862 11863 var warnNonPresent = function (target, key) { 11864 warn( 11865 "Property or method \"" + key + "\" is not defined on the instance but " + 11866 'referenced during render. Make sure that this property is reactive, ' + 11867 'either in the data option, or for class-based components, by ' + 11868 'initializing the property. ' + 11869 'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', 11870 target 11871 ); 11872 }; 11873 11874 var hasProxy = 11875 typeof Proxy !== 'undefined' && 11876 Proxy.toString().match(/native code/); 11877 11878 if (hasProxy) { 11879 var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); 11880 config.keyCodes = new Proxy(config.keyCodes, { 11881 set: function set (target, key, value) { 11882 if (isBuiltInModifier(key)) { 11883 warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key)); 11884 return false 11885 } else { 11886 target[key] = value; 11887 return true 11888 } 11889 } 11890 }); 11891 } 11892 11893 var hasHandler = { 11894 has: function has (target, key) { 11895 var has = key in target; 11896 var isAllowed = allowedGlobals(key) || key.charAt(0) === '_'; 11897 if (!has && !isAllowed) { 11898 warnNonPresent(target, key); 11899 } 11900 return has || !isAllowed 11901 } 11902 }; 11903 11904 var getHandler = { 11905 get: function get (target, key) { 11906 if (typeof key === 'string' && !(key in target)) { 11907 warnNonPresent(target, key); 11908 } 11909 return target[key] 11910 } 11911 }; 11912 11913 initProxy = function initProxy (vm) { 11914 if (hasProxy) { 11915 // determine which proxy handler to use 11916 var options = vm.$options; 11917 var handlers = options.render && options.render._withStripped 11918 ? getHandler 11919 : hasHandler; 11920 vm._renderProxy = new Proxy(vm, handlers); 11921 } else { 11922 vm._renderProxy = vm; 11923 } 11924 }; 11925} 11926 11927/* */ 11928 11929var seenObjects = new _Set(); 11930 11931/** 11932 * Recursively traverse an object to evoke all converted 11933 * getters, so that every nested property inside the object 11934 * is collected as a "deep" dependency. 11935 */ 11936function traverse (val) { 11937 _traverse(val, seenObjects); 11938 seenObjects.clear(); 11939} 11940 11941function _traverse (val, seen) { 11942 var i, keys; 11943 var isA = Array.isArray(val); 11944 if ((!isA && !isObject(val)) || Object.isFrozen(val)) { 11945 return 11946 } 11947 if (val.__ob__) { 11948 var depId = val.__ob__.dep.id; 11949 if (seen.has(depId)) { 11950 return 11951 } 11952 seen.add(depId); 11953 } 11954 if (isA) { 11955 i = val.length; 11956 while (i--) { _traverse(val[i], seen); } 11957 } else { 11958 keys = Object.keys(val); 11959 i = keys.length; 11960 while (i--) { _traverse(val[keys[i]], seen); } 11961 } 11962} 11963 11964/* */ 11965 11966var normalizeEvent = cached(function (name) { 11967 var passive = name.charAt(0) === '&'; 11968 name = passive ? name.slice(1) : name; 11969 var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first 11970 name = once$$1 ? name.slice(1) : name; 11971 var capture = name.charAt(0) === '!'; 11972 name = capture ? name.slice(1) : name; 11973 return { 11974 name: name, 11975 once: once$$1, 11976 capture: capture, 11977 passive: passive 11978 } 11979}); 11980 11981function createFnInvoker (fns) { 11982 function invoker () { 11983 var arguments$1 = arguments; 11984 11985 var fns = invoker.fns; 11986 if (Array.isArray(fns)) { 11987 var cloned = fns.slice(); 11988 for (var i = 0; i < cloned.length; i++) { 11989 cloned[i].apply(null, arguments$1); 11990 } 11991 } else { 11992 // return handler return value for single handlers 11993 return fns.apply(null, arguments) 11994 } 11995 } 11996 invoker.fns = fns; 11997 return invoker 11998} 11999 12000function updateListeners ( 12001 on, 12002 oldOn, 12003 add, 12004 remove$$1, 12005 vm 12006) { 12007 var name, cur, old, event; 12008 for (name in on) { 12009 cur = on[name]; 12010 old = oldOn[name]; 12011 event = normalizeEvent(name); 12012 if (isUndef(cur)) { 12013 process.env.NODE_ENV !== 'production' && warn( 12014 "Invalid handler for event \"" + (event.name) + "\": got " + String(cur), 12015 vm 12016 ); 12017 } else if (isUndef(old)) { 12018 if (isUndef(cur.fns)) { 12019 cur = on[name] = createFnInvoker(cur); 12020 } 12021 add(event.name, cur, event.once, event.capture, event.passive); 12022 } else if (cur !== old) { 12023 old.fns = cur; 12024 on[name] = old; 12025 } 12026 } 12027 for (name in oldOn) { 12028 if (isUndef(on[name])) { 12029 event = normalizeEvent(name); 12030 remove$$1(event.name, oldOn[name], event.capture); 12031 } 12032 } 12033} 12034 12035/* */ 12036 12037function mergeVNodeHook (def, hookKey, hook) { 12038 if (def instanceof VNode) { 12039 def = def.data.hook || (def.data.hook = {}); 12040 } 12041 var invoker; 12042 var oldHook = def[hookKey]; 12043 12044 function wrappedHook () { 12045 hook.apply(this, arguments); 12046 // important: remove merged hook to ensure it's called only once 12047 // and prevent memory leak 12048 remove(invoker.fns, wrappedHook); 12049 } 12050 12051 if (isUndef(oldHook)) { 12052 // no existing hook 12053 invoker = createFnInvoker([wrappedHook]); 12054 } else { 12055 /* istanbul ignore if */ 12056 if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { 12057 // already a merged invoker 12058 invoker = oldHook; 12059 invoker.fns.push(wrappedHook); 12060 } else { 12061 // existing plain hook 12062 invoker = createFnInvoker([oldHook, wrappedHook]); 12063 } 12064 } 12065 12066 invoker.merged = true; 12067 def[hookKey] = invoker; 12068} 12069 12070/* */ 12071 12072function extractPropsFromVNodeData ( 12073 data, 12074 Ctor, 12075 tag 12076) { 12077 // we are only extracting raw values here. 12078 // validation and default values are handled in the child 12079 // component itself. 12080 var propOptions = Ctor.options.props; 12081 if (isUndef(propOptions)) { 12082 return 12083 } 12084 var res = {}; 12085 var attrs = data.attrs; 12086 var props = data.props; 12087 if (isDef(attrs) || isDef(props)) { 12088 for (var key in propOptions) { 12089 var altKey = hyphenate(key); 12090 if (process.env.NODE_ENV !== 'production') { 12091 var keyInLowerCase = key.toLowerCase(); 12092 if ( 12093 key !== keyInLowerCase && 12094 attrs && hasOwn(attrs, keyInLowerCase) 12095 ) { 12096 tip( 12097 "Prop \"" + keyInLowerCase + "\" is passed to component " + 12098 (formatComponentName(tag || Ctor)) + ", but the declared prop name is" + 12099 " \"" + key + "\". " + 12100 "Note that HTML attributes are case-insensitive and camelCased " + 12101 "props need to use their kebab-case equivalents when using in-DOM " + 12102 "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"." 12103 ); 12104 } 12105 } 12106 checkProp(res, props, key, altKey, true) || 12107 checkProp(res, attrs, key, altKey, false); 12108 } 12109 } 12110 return res 12111} 12112 12113function checkProp ( 12114 res, 12115 hash, 12116 key, 12117 altKey, 12118 preserve 12119) {
vendor: 5,228 bytes, lines 12120-12304
12120 if (isDef(hash)) { 12121 if (hasOwn(hash, key)) { 12122 res[key] = hash[key]; 12123 if (!preserve) { 12124 delete hash[key]; 12125 } 12126 return true 12127 } else if (hasOwn(hash, altKey)) { 12128 res[key] = hash[altKey]; 12129 if (!preserve) { 12130 delete hash[altKey]; 12131 } 12132 return true 12133 } 12134 } 12135 return false 12136} 12137 12138/* */ 12139 12140// The template compiler attempts to minimize the need for normalization by 12141// statically analyzing the template at compile time. 12142// 12143// For plain HTML markup, normalization can be completely skipped because the 12144// generated render function is guaranteed to return Array<VNode>. There are 12145// two cases where extra normalization is needed: 12146 12147// 1. When the children contains components - because a functional component 12148// may return an Array instead of a single root. In this case, just a simple 12149// normalization is needed - if any child is an Array, we flatten the whole 12150// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 12151// because functional components already normalize their own children. 12152function simpleNormalizeChildren (children) { 12153 for (var i = 0; i < children.length; i++) { 12154 if (Array.isArray(children[i])) { 12155 return Array.prototype.concat.apply([], children) 12156 } 12157 } 12158 return children 12159} 12160 12161// 2. When the children contains constructs that always generated nested Arrays, 12162// e.g. <template>, <slot>, v-for, or when the children is provided by user 12163// with hand-written render functions / JSX. In such cases a full normalization 12164// is needed to cater to all possible types of children values. 12165function normalizeChildren (children) { 12166 return isPrimitive(children) 12167 ? [createTextVNode(children)] 12168 : Array.isArray(children) 12169 ? normalizeArrayChildren(children) 12170 : undefined 12171} 12172 12173function isTextNode (node) { 12174 return isDef(node) && isDef(node.text) && isFalse(node.isComment) 12175} 12176 12177function normalizeArrayChildren (children, nestedIndex) { 12178 var res = []; 12179 var i, c, lastIndex, last; 12180 for (i = 0; i < children.length; i++) { 12181 c = children[i]; 12182 if (isUndef(c) || typeof c === 'boolean') { continue } 12183 lastIndex = res.length - 1; 12184 last = res[lastIndex]; 12185 // nested 12186 if (Array.isArray(c)) { 12187 if (c.length > 0) { 12188 c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)); 12189 // merge adjacent text nodes 12190 if (isTextNode(c[0]) && isTextNode(last)) { 12191 res[lastIndex] = createTextVNode(last.text + (c[0]).text); 12192 c.shift(); 12193 } 12194 res.push.apply(res, c); 12195 } 12196 } else if (isPrimitive(c)) { 12197 if (isTextNode(last)) { 12198 // merge adjacent text nodes 12199 // this is necessary for SSR hydration because text nodes are 12200 // essentially merged when rendered to HTML strings 12201 res[lastIndex] = createTextVNode(last.text + c); 12202 } else if (c !== '') { 12203 // convert primitive to vnode 12204 res.push(createTextVNode(c)); 12205 } 12206 } else { 12207 if (isTextNode(c) && isTextNode(last)) { 12208 // merge adjacent text nodes 12209 res[lastIndex] = createTextVNode(last.text + c.text); 12210 } else { 12211 // default key for nested array children (likely generated by v-for) 12212 if (isTrue(children._isVList) && 12213 isDef(c.tag) && 12214 isUndef(c.key) && 12215 isDef(nestedIndex)) { 12216 c.key = "__vlist" + nestedIndex + "_" + i + "__"; 12217 } 12218 res.push(c); 12219 } 12220 } 12221 } 12222 return res 12223} 12224 12225/* */ 12226 12227function ensureCtor (comp, base) { 12228 if ( 12229 comp.__esModule || 12230 (hasSymbol && comp[Symbol.toStringTag] === 'Module') 12231 ) { 12232 comp = comp.default; 12233 } 12234 return isObject(comp) 12235 ? base.extend(comp) 12236 : comp 12237} 12238 12239function createAsyncPlaceholder ( 12240 factory, 12241 data, 12242 context, 12243 children, 12244 tag 12245) { 12246 var node = createEmptyVNode(); 12247 node.asyncFactory = factory; 12248 node.asyncMeta = { data: data, context: context, children: children, tag: tag }; 12249 return node 12250} 12251 12252function resolveAsyncComponent ( 12253 factory, 12254 baseCtor, 12255 context 12256) { 12257 if (isTrue(factory.error) && isDef(factory.errorComp)) { 12258 return factory.errorComp 12259 } 12260 12261 if (isDef(factory.resolved)) { 12262 return factory.resolved 12263 } 12264 12265 if (isTrue(factory.loading) && isDef(factory.loadingComp)) { 12266 return factory.loadingComp 12267 } 12268 12269 if (isDef(factory.contexts)) { 12270 // already pending 12271 factory.contexts.push(context); 12272 } else { 12273 var contexts = factory.contexts = [context]; 12274 var sync = true; 12275 12276 var forceRender = function () { 12277 for (var i = 0, l = contexts.length; i < l; i++) { 12278 contexts[i].$forceUpdate(); 12279 } 12280 }; 12281 12282 var resolve = once(function (res) { 12283 // cache resolved 12284 factory.resolved = ensureCtor(res, baseCtor); 12285 // invoke callbacks only if this is not a synchronous resolve 12286 // (async resolves are shimmed as synchronous during SSR) 12287 if (!sync) { 12288 forceRender(); 12289 } 12290 }); 12291 12292 var reject = once(function (reason) { 12293 process.env.NODE_ENV !== 'production' && warn( 12294 "Failed to resolve async component: " + (String(factory)) + 12295 (reason ? ("\nReason: " + reason) : '') 12296 ); 12297 if (isDef(factory.errorComp)) { 12298 factory.error = true; 12299 forceRender(); 12300 } 12301 }); 12302 12303 var res = factory(resolve, reject); 12304
vendor: 34,863 bytes, lines 12305-13659
12305 if (isObject(res)) { 12306 if (typeof res.then === 'function') { 12307 // () => Promise 12308 if (isUndef(factory.resolved)) { 12309 res.then(resolve, reject); 12310 } 12311 } else if (isDef(res.component) && typeof res.component.then === 'function') { 12312 res.component.then(resolve, reject); 12313 12314 if (isDef(res.error)) { 12315 factory.errorComp = ensureCtor(res.error, baseCtor); 12316 } 12317 12318 if (isDef(res.loading)) { 12319 factory.loadingComp = ensureCtor(res.loading, baseCtor); 12320 if (res.delay === 0) { 12321 factory.loading = true; 12322 } else { 12323 setTimeout(function () { 12324 if (isUndef(factory.resolved) && isUndef(factory.error)) { 12325 factory.loading = true; 12326 forceRender(); 12327 } 12328 }, res.delay || 200); 12329 } 12330 } 12331 12332 if (isDef(res.timeout)) { 12333 setTimeout(function () { 12334 if (isUndef(factory.resolved)) { 12335 reject( 12336 process.env.NODE_ENV !== 'production' 12337 ? ("timeout (" + (res.timeout) + "ms)") 12338 : null 12339 ); 12340 } 12341 }, res.timeout); 12342 } 12343 } 12344 } 12345 12346 sync = false; 12347 // return in case resolved synchronously 12348 return factory.loading 12349 ? factory.loadingComp 12350 : factory.resolved 12351 } 12352} 12353 12354/* */ 12355 12356function isAsyncPlaceholder (node) { 12357 return node.isComment && node.asyncFactory 12358} 12359 12360/* */ 12361 12362function getFirstComponentChild (children) { 12363 if (Array.isArray(children)) { 12364 for (var i = 0; i < children.length; i++) { 12365 var c = children[i]; 12366 if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { 12367 return c 12368 } 12369 } 12370 } 12371} 12372 12373/* */ 12374 12375/* */ 12376 12377function initEvents (vm) { 12378 vm._events = Object.create(null); 12379 vm._hasHookEvent = false; 12380 // init parent attached events 12381 var listeners = vm.$options._parentListeners; 12382 if (listeners) { 12383 updateComponentListeners(vm, listeners); 12384 } 12385} 12386 12387var target; 12388 12389function add (event, fn, once) { 12390 if (once) { 12391 target.$once(event, fn); 12392 } else { 12393 target.$on(event, fn); 12394 } 12395} 12396 12397function remove$1 (event, fn) { 12398 target.$off(event, fn); 12399} 12400 12401function updateComponentListeners ( 12402 vm, 12403 listeners, 12404 oldListeners 12405) { 12406 target = vm; 12407 updateListeners(listeners, oldListeners || {}, add, remove$1, vm); 12408 target = undefined; 12409} 12410 12411function eventsMixin (Vue) { 12412 var hookRE = /^hook:/; 12413 Vue.prototype.$on = function (event, fn) { 12414 var this$1 = this; 12415 12416 var vm = this; 12417 if (Array.isArray(event)) { 12418 for (var i = 0, l = event.length; i < l; i++) { 12419 this$1.$on(event[i], fn); 12420 } 12421 } else { 12422 (vm._events[event] || (vm._events[event] = [])).push(fn); 12423 // optimize hook:event cost by using a boolean flag marked at registration 12424 // instead of a hash lookup 12425 if (hookRE.test(event)) { 12426 vm._hasHookEvent = true; 12427 } 12428 } 12429 return vm 12430 }; 12431 12432 Vue.prototype.$once = function (event, fn) { 12433 var vm = this; 12434 function on () { 12435 vm.$off(event, on); 12436 fn.apply(vm, arguments); 12437 } 12438 on.fn = fn; 12439 vm.$on(event, on); 12440 return vm 12441 }; 12442 12443 Vue.prototype.$off = function (event, fn) { 12444 var this$1 = this; 12445 12446 var vm = this; 12447 // all 12448 if (!arguments.length) { 12449 vm._events = Object.create(null); 12450 return vm 12451 } 12452 // array of events 12453 if (Array.isArray(event)) { 12454 for (var i = 0, l = event.length; i < l; i++) { 12455 this$1.$off(event[i], fn); 12456 } 12457 return vm 12458 } 12459 // specific event 12460 var cbs = vm._events[event]; 12461 if (!cbs) { 12462 return vm 12463 } 12464 if (!fn) { 12465 vm._events[event] = null; 12466 return vm 12467 } 12468 if (fn) { 12469 // specific handler 12470 var cb; 12471 var i$1 = cbs.length; 12472 while (i$1--) { 12473 cb = cbs[i$1]; 12474 if (cb === fn || cb.fn === fn) { 12475 cbs.splice(i$1, 1); 12476 break 12477 } 12478 } 12479 } 12480 return vm 12481 }; 12482 12483 Vue.prototype.$emit = function (event) { 12484 var vm = this; 12485 if (process.env.NODE_ENV !== 'production') { 12486 var lowerCaseEvent = event.toLowerCase(); 12487 if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) { 12488 tip( 12489 "Event \"" + lowerCaseEvent + "\" is emitted in component " + 12490 (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " + 12491 "Note that HTML attributes are case-insensitive and you cannot use " + 12492 "v-on to listen to camelCase events when using in-DOM templates. " + 12493 "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"." 12494 ); 12495 } 12496 } 12497 var cbs = vm._events[event]; 12498 if (cbs) { 12499 cbs = cbs.length > 1 ? toArray(cbs) : cbs; 12500 var args = toArray(arguments, 1); 12501 for (var i = 0, l = cbs.length; i < l; i++) { 12502 try { 12503 cbs[i].apply(vm, args); 12504 } catch (e) { 12505 handleError(e, vm, ("event handler for \"" + event + "\"")); 12506 } 12507 } 12508 } 12509 return vm 12510 }; 12511} 12512 12513/* */ 12514 12515/** 12516 * Runtime helper for resolving raw children VNodes into a slot object. 12517 */ 12518function resolveSlots ( 12519 children, 12520 context 12521) { 12522 var slots = {}; 12523 if (!children) { 12524 return slots 12525 } 12526 for (var i = 0, l = children.length; i < l; i++) { 12527 var child = children[i]; 12528 var data = child.data; 12529 // remove slot attribute if the node is resolved as a Vue slot node 12530 if (data && data.attrs && data.attrs.slot) { 12531 delete data.attrs.slot; 12532 } 12533 // named slots should only be respected if the vnode was rendered in the 12534 // same context. 12535 if ((child.context === context || child.functionalContext === context) && 12536 data && data.slot != null 12537 ) { 12538 var name = child.data.slot; 12539 var slot = (slots[name] || (slots[name] = [])); 12540 if (child.tag === 'template') { 12541 slot.push.apply(slot, child.children); 12542 } else { 12543 slot.push(child); 12544 } 12545 } else { 12546 (slots.default || (slots.default = [])).push(child); 12547 } 12548 } 12549 // ignore slots that contains only whitespace 12550 for (var name$1 in slots) { 12551 if (slots[name$1].every(isWhitespace)) { 12552 delete slots[name$1]; 12553 } 12554 } 12555 return slots 12556} 12557 12558function isWhitespace (node) { 12559 return (node.isComment && !node.asyncFactory) || node.text === ' ' 12560} 12561 12562function resolveScopedSlots ( 12563 fns, // see flow/vnode 12564 res 12565) { 12566 res = res || {}; 12567 for (var i = 0; i < fns.length; i++) { 12568 if (Array.isArray(fns[i])) { 12569 resolveScopedSlots(fns[i], res); 12570 } else { 12571 res[fns[i].key] = fns[i].fn; 12572 } 12573 } 12574 return res 12575} 12576 12577/* */ 12578 12579var activeInstance = null; 12580var isUpdatingChildComponent = false; 12581 12582function initLifecycle (vm) { 12583 var options = vm.$options; 12584 12585 // locate first non-abstract parent 12586 var parent = options.parent; 12587 if (parent && !options.abstract) { 12588 while (parent.$options.abstract && parent.$parent) { 12589 parent = parent.$parent; 12590 } 12591 parent.$children.push(vm); 12592 } 12593 12594 vm.$parent = parent; 12595 vm.$root = parent ? parent.$root : vm; 12596 12597 vm.$children = []; 12598 vm.$refs = {}; 12599 12600 vm._watcher = null; 12601 vm._inactive = null; 12602 vm._directInactive = false; 12603 vm._isMounted = false; 12604 vm._isDestroyed = false; 12605 vm._isBeingDestroyed = false; 12606} 12607 12608function lifecycleMixin (Vue) { 12609 Vue.prototype._update = function (vnode, hydrating) { 12610 var vm = this; 12611 if (vm._isMounted) { 12612 callHook(vm, 'beforeUpdate'); 12613 } 12614 var prevEl = vm.$el; 12615 var prevVnode = vm._vnode; 12616 var prevActiveInstance = activeInstance; 12617 activeInstance = vm; 12618 vm._vnode = vnode; 12619 // Vue.prototype.__patch__ is injected in entry points 12620 // based on the rendering backend used. 12621 if (!prevVnode) { 12622 // initial render 12623 vm.$el = vm.__patch__( 12624 vm.$el, vnode, hydrating, false /* removeOnly */, 12625 vm.$options._parentElm, 12626 vm.$options._refElm 12627 ); 12628 // no need for the ref nodes after initial patch 12629 // this prevents keeping a detached DOM tree in memory (#5851) 12630 vm.$options._parentElm = vm.$options._refElm = null; 12631 } else { 12632 // updates 12633 vm.$el = vm.__patch__(prevVnode, vnode); 12634 } 12635 activeInstance = prevActiveInstance; 12636 // update __vue__ reference 12637 if (prevEl) { 12638 prevEl.__vue__ = null; 12639 } 12640 if (vm.$el) { 12641 vm.$el.__vue__ = vm; 12642 } 12643 // if parent is an HOC, update its $el as well 12644 if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { 12645 vm.$parent.$el = vm.$el; 12646 } 12647 // updated hook is called by the scheduler to ensure that children are 12648 // updated in a parent's updated hook. 12649 }; 12650 12651 Vue.prototype.$forceUpdate = function () { 12652 var vm = this; 12653 if (vm._watcher) { 12654 vm._watcher.update(); 12655 } 12656 }; 12657 12658 Vue.prototype.$destroy = function () { 12659 var vm = this; 12660 if (vm._isBeingDestroyed) { 12661 return 12662 } 12663 callHook(vm, 'beforeDestroy'); 12664 vm._isBeingDestroyed = true; 12665 // remove self from parent 12666 var parent = vm.$parent; 12667 if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { 12668 remove(parent.$children, vm); 12669 } 12670 // teardown watchers 12671 if (vm._watcher) { 12672 vm._watcher.teardown(); 12673 } 12674 var i = vm._watchers.length; 12675 while (i--) { 12676 vm._watchers[i].teardown(); 12677 } 12678 // remove reference from data ob 12679 // frozen object may not have observer. 12680 if (vm._data.__ob__) { 12681 vm._data.__ob__.vmCount--; 12682 } 12683 // call the last hook... 12684 vm._isDestroyed = true; 12685 // invoke destroy hooks on current rendered tree 12686 vm.__patch__(vm._vnode, null); 12687 // fire destroyed hook 12688 callHook(vm, 'destroyed'); 12689 // turn off all instance listeners. 12690 vm.$off(); 12691 // remove __vue__ reference 12692 if (vm.$el) { 12693 vm.$el.__vue__ = null; 12694 } 12695 // release circular reference (#6759) 12696 if (vm.$vnode) { 12697 vm.$vnode.parent = null; 12698 } 12699 }; 12700} 12701 12702function mountComponent ( 12703 vm, 12704 el, 12705 hydrating 12706) { 12707 vm.$el = el; 12708 if (!vm.$options.render) { 12709 vm.$options.render = createEmptyVNode; 12710 if (process.env.NODE_ENV !== 'production') { 12711 /* istanbul ignore if */ 12712 if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') || 12713 vm.$options.el || el) { 12714 warn( 12715 'You are using the runtime-only build of Vue where the template ' + 12716 'compiler is not available. Either pre-compile the templates into ' + 12717 'render functions, or use the compiler-included build.', 12718 vm 12719 ); 12720 } else { 12721 warn( 12722 'Failed to mount component: template or render function not defined.', 12723 vm 12724 ); 12725 } 12726 } 12727 } 12728 callHook(vm, 'beforeMount'); 12729 12730 var updateComponent; 12731 /* istanbul ignore if */ 12732 if (process.env.NODE_ENV !== 'production' && config.performance && mark) { 12733 updateComponent = function () { 12734 var name = vm._name; 12735 var id = vm._uid; 12736 var startTag = "vue-perf-start:" + id; 12737 var endTag = "vue-perf-end:" + id; 12738 12739 mark(startTag); 12740 var vnode = vm._render(); 12741 mark(endTag); 12742 measure(("vue " + name + " render"), startTag, endTag); 12743 12744 mark(startTag); 12745 vm._update(vnode, hydrating); 12746 mark(endTag); 12747 measure(("vue " + name + " patch"), startTag, endTag); 12748 }; 12749 } else { 12750 updateComponent = function () { 12751 vm._update(vm._render(), hydrating); 12752 }; 12753 } 12754 12755 vm._watcher = new Watcher(vm, updateComponent, noop); 12756 hydrating = false; 12757 12758 // manually mounted instance, call mounted on self 12759 // mounted is called for render-created child components in its inserted hook 12760 if (vm.$vnode == null) { 12761 vm._isMounted = true; 12762 callHook(vm, 'mounted'); 12763 } 12764 return vm 12765} 12766 12767function updateChildComponent ( 12768 vm, 12769 propsData, 12770 listeners, 12771 parentVnode, 12772 renderChildren 12773) { 12774 if (process.env.NODE_ENV !== 'production') { 12775 isUpdatingChildComponent = true; 12776 } 12777 12778 // determine whether component has slot children 12779 // we need to do this before overwriting $options._renderChildren 12780 var hasChildren = !!( 12781 renderChildren || // has new static slots 12782 vm.$options._renderChildren || // has old static slots 12783 parentVnode.data.scopedSlots || // has new scoped slots 12784 vm.$scopedSlots !== emptyObject // has old scoped slots 12785 ); 12786 12787 vm.$options._parentVnode = parentVnode; 12788 vm.$vnode = parentVnode; // update vm's placeholder node without re-render 12789 12790 if (vm._vnode) { // update child tree's parent 12791 vm._vnode.parent = parentVnode; 12792 } 12793 vm.$options._renderChildren = renderChildren; 12794 12795 // update $attrs and $listeners hash 12796 // these are also reactive so they may trigger child update if the child 12797 // used them during render 12798 vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject; 12799 vm.$listeners = listeners || emptyObject; 12800 12801 // update props 12802 if (propsData && vm.$options.props) { 12803 observerState.shouldConvert = false; 12804 var props = vm._props; 12805 var propKeys = vm.$options._propKeys || []; 12806 for (var i = 0; i < propKeys.length; i++) { 12807 var key = propKeys[i]; 12808 props[key] = validateProp(key, vm.$options.props, propsData, vm); 12809 } 12810 observerState.shouldConvert = true; 12811 // keep a copy of raw propsData 12812 vm.$options.propsData = propsData; 12813 } 12814 12815 // update listeners 12816 if (listeners) { 12817 var oldListeners = vm.$options._parentListeners; 12818 vm.$options._parentListeners = listeners; 12819 updateComponentListeners(vm, listeners, oldListeners); 12820 } 12821 // resolve slots + force update if has children 12822 if (hasChildren) { 12823 vm.$slots = resolveSlots(renderChildren, parentVnode.context); 12824 vm.$forceUpdate(); 12825 } 12826 12827 if (process.env.NODE_ENV !== 'production') { 12828 isUpdatingChildComponent = false; 12829 } 12830} 12831 12832function isInInactiveTree (vm) { 12833 while (vm && (vm = vm.$parent)) { 12834 if (vm._inactive) { return true } 12835 } 12836 return false 12837} 12838 12839function activateChildComponent (vm, direct) { 12840 if (direct) { 12841 vm._directInactive = false; 12842 if (isInInactiveTree(vm)) { 12843 return 12844 } 12845 } else if (vm._directInactive) { 12846 return 12847 } 12848 if (vm._inactive || vm._inactive === null) { 12849 vm._inactive = false; 12850 for (var i = 0; i < vm.$children.length; i++) { 12851 activateChildComponent(vm.$children[i]); 12852 } 12853 callHook(vm, 'activated'); 12854 } 12855} 12856 12857function deactivateChildComponent (vm, direct) { 12858 if (direct) { 12859 vm._directInactive = true; 12860 if (isInInactiveTree(vm)) { 12861 return 12862 } 12863 } 12864 if (!vm._inactive) { 12865 vm._inactive = true; 12866 for (var i = 0; i < vm.$children.length; i++) { 12867 deactivateChildComponent(vm.$children[i]); 12868 } 12869 callHook(vm, 'deactivated'); 12870 } 12871} 12872 12873function callHook (vm, hook) { 12874 var handlers = vm.$options[hook]; 12875 if (handlers) { 12876 for (var i = 0, j = handlers.length; i < j; i++) { 12877 try { 12878 handlers[i].call(vm); 12879 } catch (e) { 12880 handleError(e, vm, (hook + " hook")); 12881 } 12882 } 12883 } 12884 if (vm._hasHookEvent) { 12885 vm.$emit('hook:' + hook); 12886 } 12887} 12888 12889/* */ 12890 12891 12892var MAX_UPDATE_COUNT = 100; 12893 12894var queue = []; 12895var activatedChildren = []; 12896var has = {}; 12897var circular = {}; 12898var waiting = false; 12899var flushing = false; 12900var index = 0; 12901 12902/** 12903 * Reset the scheduler's state. 12904 */ 12905function resetSchedulerState () { 12906 index = queue.length = activatedChildren.length = 0; 12907 has = {}; 12908 if (process.env.NODE_ENV !== 'production') { 12909 circular = {}; 12910 } 12911 waiting = flushing = false; 12912} 12913 12914/** 12915 * Flush both queues and run the watchers. 12916 */ 12917function flushSchedulerQueue () { 12918 flushing = true; 12919 var watcher, id; 12920 12921 // Sort queue before flush. 12922 // This ensures that: 12923 // 1. Components are updated from parent to child. (because parent is always 12924 // created before the child) 12925 // 2. A component's user watchers are run before its render watcher (because 12926 // user watchers are created before the render watcher) 12927 // 3. If a component is destroyed during a parent component's watcher run, 12928 // its watchers can be skipped. 12929 queue.sort(function (a, b) { return a.id - b.id; }); 12930 12931 // do not cache length because more watchers might be pushed 12932 // as we run existing watchers 12933 for (index = 0; index < queue.length; index++) { 12934 watcher = queue[index]; 12935 id = watcher.id; 12936 has[id] = null; 12937 watcher.run(); 12938 // in dev build, check and stop circular updates. 12939 if (process.env.NODE_ENV !== 'production' && has[id] != null) { 12940 circular[id] = (circular[id] || 0) + 1; 12941 if (circular[id] > MAX_UPDATE_COUNT) { 12942 warn( 12943 'You may have an infinite update loop ' + ( 12944 watcher.user 12945 ? ("in watcher with expression \"" + (watcher.expression) + "\"") 12946 : "in a component render function." 12947 ), 12948 watcher.vm 12949 ); 12950 break 12951 } 12952 } 12953 } 12954 12955 // keep copies of post queues before resetting state 12956 var activatedQueue = activatedChildren.slice(); 12957 var updatedQueue = queue.slice(); 12958 12959 resetSchedulerState(); 12960 12961 // call component updated and activated hooks 12962 callActivatedHooks(activatedQueue); 12963 callUpdatedHooks(updatedQueue); 12964 12965 // devtool hook 12966 /* istanbul ignore if */ 12967 if (devtools && config.devtools) { 12968 devtools.emit('flush'); 12969 } 12970} 12971 12972function callUpdatedHooks (queue) { 12973 var i = queue.length; 12974 while (i--) { 12975 var watcher = queue[i]; 12976 var vm = watcher.vm; 12977 if (vm._watcher === watcher && vm._isMounted) { 12978 callHook(vm, 'updated'); 12979 } 12980 } 12981} 12982 12983/** 12984 * Queue a kept-alive component that was activated during patch. 12985 * The queue will be processed after the entire tree has been patched. 12986 */ 12987function queueActivatedComponent (vm) { 12988 // setting _inactive to false here so that a render function can 12989 // rely on checking whether it's in an inactive tree (e.g. router-view) 12990 vm._inactive = false; 12991 activatedChildren.push(vm); 12992} 12993 12994function callActivatedHooks (queue) { 12995 for (var i = 0; i < queue.length; i++) { 12996 queue[i]._inactive = true; 12997 activateChildComponent(queue[i], true /* true */); 12998 } 12999} 13000 13001/** 13002 * Push a watcher into the watcher queue. 13003 * Jobs with duplicate IDs will be skipped unless it's 13004 * pushed when the queue is being flushed. 13005 */ 13006function queueWatcher (watcher) { 13007 var id = watcher.id; 13008 if (has[id] == null) { 13009 has[id] = true; 13010 if (!flushing) { 13011 queue.push(watcher); 13012 } else { 13013 // if already flushing, splice the watcher based on its id 13014 // if already past its id, it will be run next immediately. 13015 var i = queue.length - 1; 13016 while (i > index && queue[i].id > watcher.id) { 13017 i--; 13018 } 13019 queue.splice(i + 1, 0, watcher); 13020 } 13021 // queue the flush 13022 if (!waiting) { 13023 waiting = true; 13024 nextTick(flushSchedulerQueue); 13025 } 13026 } 13027} 13028 13029/* */ 13030 13031var uid$2 = 0; 13032 13033/** 13034 * A watcher parses an expression, collects dependencies, 13035 * and fires callback when the expression value changes. 13036 * This is used for both the $watch() api and directives. 13037 */ 13038var Watcher = function Watcher ( 13039 vm, 13040 expOrFn, 13041 cb, 13042 options 13043) { 13044 this.vm = vm; 13045 vm._watchers.push(this); 13046 // options 13047 if (options) { 13048 this.deep = !!options.deep; 13049 this.user = !!options.user; 13050 this.lazy = !!options.lazy; 13051 this.sync = !!options.sync; 13052 } else { 13053 this.deep = this.user = this.lazy = this.sync = false; 13054 } 13055 this.cb = cb; 13056 this.id = ++uid$2; // uid for batching 13057 this.active = true; 13058 this.dirty = this.lazy; // for lazy watchers 13059 this.deps = []; 13060 this.newDeps = []; 13061 this.depIds = new _Set(); 13062 this.newDepIds = new _Set(); 13063 this.expression = process.env.NODE_ENV !== 'production' 13064 ? expOrFn.toString() 13065 : ''; 13066 // parse expression for getter 13067 if (typeof expOrFn === 'function') { 13068 this.getter = expOrFn; 13069 } else { 13070 this.getter = parsePath(expOrFn); 13071 if (!this.getter) { 13072 this.getter = function () {}; 13073 process.env.NODE_ENV !== 'production' && warn( 13074 "Failed watching path: \"" + expOrFn + "\" " + 13075 'Watcher only accepts simple dot-delimited paths. ' + 13076 'For full control, use a function instead.', 13077 vm 13078 ); 13079 } 13080 } 13081 this.value = this.lazy 13082 ? undefined 13083 : this.get(); 13084}; 13085 13086/** 13087 * Evaluate the getter, and re-collect dependencies. 13088 */ 13089Watcher.prototype.get = function get () { 13090 pushTarget(this); 13091 var value; 13092 var vm = this.vm; 13093 try { 13094 value = this.getter.call(vm, vm); 13095 } catch (e) { 13096 if (this.user) { 13097 handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\"")); 13098 } else { 13099 throw e 13100 } 13101 } finally { 13102 // "touch" every property so they are all tracked as 13103 // dependencies for deep watching 13104 if (this.deep) { 13105 traverse(value); 13106 } 13107 popTarget(); 13108 this.cleanupDeps(); 13109 } 13110 return value 13111}; 13112 13113/** 13114 * Add a dependency to this directive. 13115 */ 13116Watcher.prototype.addDep = function addDep (dep) { 13117 var id = dep.id; 13118 if (!this.newDepIds.has(id)) { 13119 this.newDepIds.add(id); 13120 this.newDeps.push(dep); 13121 if (!this.depIds.has(id)) { 13122 dep.addSub(this); 13123 } 13124 } 13125}; 13126 13127/** 13128 * Clean up for dependency collection. 13129 */ 13130Watcher.prototype.cleanupDeps = function cleanupDeps () { 13131 var this$1 = this; 13132 13133 var i = this.deps.length; 13134 while (i--) { 13135 var dep = this$1.deps[i]; 13136 if (!this$1.newDepIds.has(dep.id)) { 13137 dep.removeSub(this$1); 13138 } 13139 } 13140 var tmp = this.depIds; 13141 this.depIds = this.newDepIds; 13142 this.newDepIds = tmp; 13143 this.newDepIds.clear(); 13144 tmp = this.deps; 13145 this.deps = this.newDeps; 13146 this.newDeps = tmp; 13147 this.newDeps.length = 0; 13148}; 13149 13150/** 13151 * Subscriber interface. 13152 * Will be called when a dependency changes. 13153 */ 13154Watcher.prototype.update = function update () { 13155 /* istanbul ignore else */ 13156 if (this.lazy) { 13157 this.dirty = true; 13158 } else if (this.sync) { 13159 this.run(); 13160 } else { 13161 queueWatcher(this); 13162 } 13163}; 13164 13165/** 13166 * Scheduler job interface. 13167 * Will be called by the scheduler. 13168 */ 13169Watcher.prototype.run = function run () { 13170 if (this.active) { 13171 var value = this.get(); 13172 if ( 13173 value !== this.value || 13174 // Deep watchers and watchers on Object/Arrays should fire even 13175 // when the value is the same, because the value may 13176 // have mutated. 13177 isObject(value) || 13178 this.deep 13179 ) { 13180 // set new value 13181 var oldValue = this.value; 13182 this.value = value; 13183 if (this.user) { 13184 try { 13185 this.cb.call(this.vm, value, oldValue); 13186 } catch (e) { 13187 handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\"")); 13188 } 13189 } else { 13190 this.cb.call(this.vm, value, oldValue); 13191 } 13192 } 13193 } 13194}; 13195 13196/** 13197 * Evaluate the value of the watcher. 13198 * This only gets called for lazy watchers. 13199 */ 13200Watcher.prototype.evaluate = function evaluate () { 13201 this.value = this.get(); 13202 this.dirty = false; 13203}; 13204 13205/** 13206 * Depend on all deps collected by this watcher. 13207 */ 13208Watcher.prototype.depend = function depend () { 13209 var this$1 = this; 13210 13211 var i = this.deps.length; 13212 while (i--) { 13213 this$1.deps[i].depend(); 13214 } 13215}; 13216 13217/** 13218 * Remove self from all dependencies' subscriber list. 13219 */ 13220Watcher.prototype.teardown = function teardown () { 13221 var this$1 = this; 13222 13223 if (this.active) { 13224 // remove self from vm's watcher list 13225 // this is a somewhat expensive operation so we skip it 13226 // if the vm is being destroyed. 13227 if (!this.vm._isBeingDestroyed) { 13228 remove(this.vm._watchers, this); 13229 } 13230 var i = this.deps.length; 13231 while (i--) { 13232 this$1.deps[i].removeSub(this$1); 13233 } 13234 this.active = false; 13235 } 13236}; 13237 13238/* */ 13239 13240var sharedPropertyDefinition = { 13241 enumerable: true, 13242 configurable: true, 13243 get: noop, 13244 set: noop 13245}; 13246 13247function proxy (target, sourceKey, key) { 13248 sharedPropertyDefinition.get = function proxyGetter () { 13249 return this[sourceKey][key] 13250 }; 13251 sharedPropertyDefinition.set = function proxySetter (val) { 13252 this[sourceKey][key] = val; 13253 }; 13254 Object.defineProperty(target, key, sharedPropertyDefinition); 13255} 13256 13257function initState (vm) { 13258 vm._watchers = []; 13259 var opts = vm.$options; 13260 if (opts.props) { initProps(vm, opts.props); } 13261 if (opts.methods) { initMethods(vm, opts.methods); } 13262 if (opts.data) { 13263 initData(vm); 13264 } else { 13265 observe(vm._data = {}, true /* asRootData */); 13266 } 13267 if (opts.computed) { initComputed(vm, opts.computed); } 13268 if (opts.watch && opts.watch !== nativeWatch) { 13269 initWatch(vm, opts.watch); 13270 } 13271} 13272 13273function initProps (vm, propsOptions) { 13274 var propsData = vm.$options.propsData || {}; 13275 var props = vm._props = {}; 13276 // cache prop keys so that future props updates can iterate using Array 13277 // instead of dynamic object key enumeration. 13278 var keys = vm.$options._propKeys = []; 13279 var isRoot = !vm.$parent; 13280 // root instance props should be converted 13281 observerState.shouldConvert = isRoot; 13282 var loop = function ( key ) { 13283 keys.push(key); 13284 var value = validateProp(key, propsOptions, propsData, vm); 13285 /* istanbul ignore else */ 13286 if (process.env.NODE_ENV !== 'production') { 13287 var hyphenatedKey = hyphenate(key); 13288 if (isReservedAttribute(hyphenatedKey) || 13289 config.isReservedAttr(hyphenatedKey)) { 13290 warn( 13291 ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), 13292 vm 13293 ); 13294 } 13295 defineReactive(props, key, value, function () { 13296 if (vm.$parent && !isUpdatingChildComponent) { 13297 warn( 13298 "Avoid mutating a prop directly since the value will be " + 13299 "overwritten whenever the parent component re-renders. " + 13300 "Instead, use a data or computed property based on the prop's " + 13301 "value. Prop being mutated: \"" + key + "\"", 13302 vm 13303 ); 13304 } 13305 }); 13306 } else { 13307 defineReactive(props, key, value); 13308 } 13309 // static props are already proxied on the component's prototype 13310 // during Vue.extend(). We only need to proxy props defined at 13311 // instantiation here. 13312 if (!(key in vm)) { 13313 proxy(vm, "_props", key); 13314 } 13315 }; 13316 13317 for (var key in propsOptions) loop( key ); 13318 observerState.shouldConvert = true; 13319} 13320 13321function initData (vm) { 13322 var data = vm.$options.data; 13323 data = vm._data = typeof data === 'function' 13324 ? getData(data, vm) 13325 : data || {}; 13326 if (!isPlainObject(data)) { 13327 data = {}; 13328 process.env.NODE_ENV !== 'production' && warn( 13329 'data functions should return an object:\n' + 13330 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', 13331 vm 13332 ); 13333 } 13334 // proxy data on instance 13335 var keys = Object.keys(data); 13336 var props = vm.$options.props; 13337 var methods = vm.$options.methods; 13338 var i = keys.length; 13339 while (i--) { 13340 var key = keys[i]; 13341 if (process.env.NODE_ENV !== 'production') { 13342 if (methods && hasOwn(methods, key)) { 13343 warn( 13344 ("Method \"" + key + "\" has already been defined as a data property."), 13345 vm 13346 ); 13347 } 13348 } 13349 if (props && hasOwn(props, key)) { 13350 process.env.NODE_ENV !== 'production' && warn( 13351 "The data property \"" + key + "\" is already declared as a prop. " + 13352 "Use prop default value instead.", 13353 vm 13354 ); 13355 } else if (!isReserved(key)) { 13356 proxy(vm, "_data", key); 13357 } 13358 } 13359 // observe data 13360 observe(data, true /* asRootData */); 13361} 13362 13363function getData (data, vm) { 13364 try { 13365 return data.call(vm, vm) 13366 } catch (e) { 13367 handleError(e, vm, "data()"); 13368 return {} 13369 } 13370} 13371 13372var computedWatcherOptions = { lazy: true }; 13373 13374function initComputed (vm, computed) { 13375 var watchers = vm._computedWatchers = Object.create(null); 13376 // computed properties are just getters during SSR 13377 var isSSR = isServerRendering(); 13378 13379 for (var key in computed) { 13380 var userDef = computed[key]; 13381 var getter = typeof userDef === 'function' ? userDef : userDef.get; 13382 if (process.env.NODE_ENV !== 'production' && getter == null) { 13383 warn( 13384 ("Getter is missing for computed property \"" + key + "\"."), 13385 vm 13386 ); 13387 } 13388 13389 if (!isSSR) { 13390 // create internal watcher for the computed property. 13391 watchers[key] = new Watcher( 13392 vm, 13393 getter || noop, 13394 noop, 13395 computedWatcherOptions 13396 ); 13397 } 13398 13399 // component-defined computed properties are already defined on the 13400 // component prototype. We only need to define computed properties defined 13401 // at instantiation here. 13402 if (!(key in vm)) { 13403 defineComputed(vm, key, userDef); 13404 } else if (process.env.NODE_ENV !== 'production') { 13405 if (key in vm.$data) { 13406 warn(("The computed property \"" + key + "\" is already defined in data."), vm); 13407 } else if (vm.$options.props && key in vm.$options.props) { 13408 warn(("The computed property \"" + key + "\" is already defined as a prop."), vm); 13409 } 13410 } 13411 } 13412} 13413 13414function defineComputed ( 13415 target, 13416 key, 13417 userDef 13418) { 13419 var shouldCache = !isServerRendering(); 13420 if (typeof userDef === 'function') { 13421 sharedPropertyDefinition.get = shouldCache 13422 ? createComputedGetter(key) 13423 : userDef; 13424 sharedPropertyDefinition.set = noop; 13425 } else { 13426 sharedPropertyDefinition.get = userDef.get 13427 ? shouldCache && userDef.cache !== false 13428 ? createComputedGetter(key) 13429 : userDef.get 13430 : noop; 13431 sharedPropertyDefinition.set = userDef.set 13432 ? userDef.set 13433 : noop; 13434 } 13435 if (process.env.NODE_ENV !== 'production' && 13436 sharedPropertyDefinition.set === noop) { 13437 sharedPropertyDefinition.set = function () { 13438 warn( 13439 ("Computed property \"" + key + "\" was assigned to but it has no setter."), 13440 this 13441 ); 13442 }; 13443 } 13444 Object.defineProperty(target, key, sharedPropertyDefinition); 13445} 13446 13447function createComputedGetter (key) { 13448 return function computedGetter () { 13449 var watcher = this._computedWatchers && this._computedWatchers[key]; 13450 if (watcher) { 13451 if (watcher.dirty) { 13452 watcher.evaluate(); 13453 } 13454 if (Dep.target) { 13455 watcher.depend(); 13456 } 13457 return watcher.value 13458 } 13459 } 13460} 13461 13462function initMethods (vm, methods) { 13463 var props = vm.$options.props; 13464 for (var key in methods) { 13465 if (process.env.NODE_ENV !== 'production') { 13466 if (methods[key] == null) { 13467 warn( 13468 "Method \"" + key + "\" has an undefined value in the component definition. " + 13469 "Did you reference the function correctly?", 13470 vm 13471 ); 13472 } 13473 if (props && hasOwn(props, key)) { 13474 warn( 13475 ("Method \"" + key + "\" has already been defined as a prop."), 13476 vm 13477 ); 13478 } 13479 if ((key in vm) && isReserved(key)) { 13480 warn( 13481 "Method \"" + key + "\" conflicts with an existing Vue instance method. " + 13482 "Avoid defining component methods that start with _ or $." 13483 ); 13484 } 13485 } 13486 vm[key] = methods[key] == null ? noop : bind(methods[key], vm); 13487 } 13488} 13489 13490function initWatch (vm, watch) { 13491 for (var key in watch) { 13492 var handler = watch[key]; 13493 if (Array.isArray(handler)) { 13494 for (var i = 0; i < handler.length; i++) { 13495 createWatcher(vm, key, handler[i]); 13496 } 13497 } else { 13498 createWatcher(vm, key, handler); 13499 } 13500 } 13501} 13502 13503function createWatcher ( 13504 vm, 13505 keyOrFn, 13506 handler, 13507 options 13508) { 13509 if (isPlainObject(handler)) { 13510 options = handler; 13511 handler = handler.handler; 13512 } 13513 if (typeof handler === 'string') { 13514 handler = vm[handler]; 13515 } 13516 return vm.$watch(keyOrFn, handler, options) 13517} 13518 13519function stateMixin (Vue) { 13520 // flow somehow has problems with directly declared definition object 13521 // when using Object.defineProperty, so we have to procedurally build up 13522 // the object here. 13523 var dataDef = {}; 13524 dataDef.get = function () { return this._data }; 13525 var propsDef = {}; 13526 propsDef.get = function () { return this._props }; 13527 if (process.env.NODE_ENV !== 'production') { 13528 dataDef.set = function (newData) { 13529 warn( 13530 'Avoid replacing instance root $data. ' + 13531 'Use nested data properties instead.', 13532 this 13533 ); 13534 }; 13535 propsDef.set = function () { 13536 warn("$props is readonly.", this); 13537 }; 13538 } 13539 Object.defineProperty(Vue.prototype, '$data', dataDef); 13540 Object.defineProperty(Vue.prototype, '$props', propsDef); 13541 13542 Vue.prototype.$set = set; 13543 Vue.prototype.$delete = del; 13544 13545 Vue.prototype.$watch = function ( 13546 expOrFn, 13547 cb, 13548 options 13549 ) { 13550 var vm = this; 13551 if (isPlainObject(cb)) { 13552 return createWatcher(vm, expOrFn, cb, options) 13553 } 13554 options = options || {}; 13555 options.user = true; 13556 var watcher = new Watcher(vm, expOrFn, cb, options); 13557 if (options.immediate) { 13558 cb.call(vm, watcher.value); 13559 } 13560 return function unwatchFn () { 13561 watcher.teardown(); 13562 } 13563 }; 13564} 13565 13566/* */ 13567 13568function initProvide (vm) { 13569 var provide = vm.$options.provide; 13570 if (provide) { 13571 vm._provided = typeof provide === 'function' 13572 ? provide.call(vm) 13573 : provide; 13574 } 13575} 13576 13577function initInjections (vm) { 13578 var result = resolveInject(vm.$options.inject, vm); 13579 if (result) { 13580 observerState.shouldConvert = false; 13581 Object.keys(result).forEach(function (key) { 13582 /* istanbul ignore else */ 13583 if (process.env.NODE_ENV !== 'production') { 13584 defineReactive(vm, key, result[key], function () { 13585 warn( 13586 "Avoid mutating an injected value directly since the changes will be " + 13587 "overwritten whenever the provided component re-renders. " + 13588 "injection being mutated: \"" + key + "\"", 13589 vm 13590 ); 13591 }); 13592 } else { 13593 defineReactive(vm, key, result[key]); 13594 } 13595 }); 13596 observerState.shouldConvert = true; 13597 } 13598} 13599 13600function resolveInject (inject, vm) { 13601 if (inject) { 13602 // inject is :any because flow is not smart enough to figure out cached 13603 var result = Object.create(null); 13604 var keys = hasSymbol 13605 ? Reflect.ownKeys(inject).filter(function (key) { 13606 /* istanbul ignore next */ 13607 return Object.getOwnPropertyDescriptor(inject, key).enumerable 13608 }) 13609 : Object.keys(inject); 13610 13611 for (var i = 0; i < keys.length; i++) { 13612 var key = keys[i]; 13613 var provideKey = inject[key].from; 13614 var source = vm; 13615 while (source) { 13616 if (source._provided && provideKey in source._provided) { 13617 result[key] = source._provided[provideKey]; 13618 break 13619 } 13620 source = source.$parent; 13621 } 13622 if (!source) { 13623 if ('default' in inject[key]) { 13624 var provideDefault = inject[key].default; 13625 result[key] = typeof provideDefault === 'function' 13626 ? provideDefault.call(vm) 13627 : provideDefault; 13628 } else if (process.env.NODE_ENV !== 'production') { 13629 warn(("Injection \"" + key + "\" not found"), vm); 13630 } 13631 } 13632 } 13633 return result 13634 } 13635} 13636 13637/* */ 13638 13639/** 13640 * Runtime helper for rendering v-for lists. 13641 */ 13642function renderList ( 13643 val, 13644 render 13645) { 13646 var ret, i, l, keys, key; 13647 if (Array.isArray(val) || typeof val === 'string') { 13648 ret = new Array(val.length); 13649 for (i = 0, l = val.length; i < l; i++) { 13650 ret[i] = render(val[i], i); 13651 } 13652 } else if (typeof val === 'number') { 13653 ret = new Array(val); 13654 for (i = 0; i < val; i++) { 13655 ret[i] = render(i + 1, i); 13656 } 13657 } else if (isObject(val)) { 13658 keys = Object.keys(val); 13659 ret = new Array(keys.length);
13660 for (i = 0, l = keys.length; i < l; i++) { 13661 key = keys[i]; 13662 ret[i] = render(val[key], key, i); 13663 } 13664 } 13665 if (isDef(ret)) { 13666 (ret)._isVList = true; 13667 } 13668 return ret 13669} 13670 13671/* */ 13672 13673/** 13674 * Runtime helper for rendering <slot> 13675 */ 13676function renderSlot ( 13677 name, 13678 fallback, 13679 props, 13680 bindObject 13681) { 13682 var scopedSlotFn = this.$scopedSlots[name]; 13683 var nodes; 13684 if (scopedSlotFn) { // scoped slot 13685 props = props || {}; 13686 if (bindObject) { 13687 if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) { 13688 warn( 13689 'slot v-bind without argument expects an Object', 13690 this 13691 ); 13692 } 13693 props = extend(extend({}, bindObject), props); 13694 } 13695 nodes = scopedSlotFn(props) || fallback; 13696 } else { 13697 var slotNodes = this.$slots[name]; 13698 // warn duplicate slot usage 13699 if (slotNodes) { 13700 if (process.env.NODE_ENV !== 'production' && slotNodes._rendered) { 13701 warn( 13702 "Duplicate presence of slot \"" + name + "\" found in the same render tree " + 13703 "- this will likely cause render errors.", 13704 this 13705 ); 13706 } 13707 slotNodes._rendered = true; 13708 } 13709 nodes = slotNodes || fallback; 13710 } 13711 13712 var target = props && props.slot; 13713 if (target) { 13714 return this.$createElement('template', { slot: target }, nodes) 13715 } else { 13716 return nodes 13717 } 13718} 13719 13720/* */ 13721 13722/** 13723 * Runtime helper for resolving filters 13724 */ 13725function resolveFilter (id) { 13726 return resolveAsset(this.$options, 'filters', id, true) || identity 13727} 13728 13729/* */ 13730 13731/** 13732 * Runtime helper for checking keyCodes from config. 13733 * exposed as Vue.prototype._k 13734 * passing in eventKeyName as last argument separately for backwards compat 13735 */ 13736function checkKeyCodes ( 13737 eventKeyCode, 13738 key, 13739 builtInAlias, 13740 eventKeyName 13741) { 13742 var keyCodes = config.keyCodes[key] || builtInAlias; 13743 if (keyCodes) { 13744 if (Array.isArray(keyCodes)) { 13745 return keyCodes.indexOf(eventKeyCode) === -1 13746 } else { 13747 return keyCodes !== eventKeyCode 13748 } 13749 } else if (eventKeyName) { 13750 return hyphenate(eventKeyName) !== key 13751 } 13752} 13753 13754/* */ 13755 13756/** 13757 * Runtime helper for merging v-bind="object" into a VNode's data. 13758 */ 13759function bindObjectProps ( 13760 data, 13761 tag, 13762 value, 13763 asProp, 13764 isSync 13765) { 13766 if (value) { 13767 if (!isObject(value)) { 13768 process.env.NODE_ENV !== 'production' && warn( 13769 'v-bind without argument expects an Object or Array value', 13770 this 13771 ); 13772 } else { 13773 if (Array.isArray(value)) { 13774 value = toObject(value); 13775 } 13776 var hash; 13777 var loop = function ( key ) { 13778 if ( 13779 key === 'class' || 13780 key === 'style' || 13781 isReservedAttribute(key) 13782 ) { 13783 hash = data; 13784 } else { 13785 var type = data.attrs && data.attrs.type; 13786 hash = asProp || config.mustUseProp(tag, type, key) 13787 ? data.domProps || (data.domProps = {}) 13788 : data.attrs || (data.attrs = {}); 13789 } 13790 if (!(key in hash)) { 13791 hash[key] = value[key]; 13792 13793 if (isSync) { 13794 var on = data.on || (data.on = {}); 13795 on[("update:" + key)] = function ($event) { 13796 value[key] = $event; 13797 }; 13798 } 13799 } 13800 }; 13801 13802 for (var key in value) loop( key ); 13803 } 13804 } 13805 return data 13806} 13807 13808/* */ 13809 13810/** 13811 * Runtime helper for rendering static trees. 13812 */
13813function renderStatic ( 13814 index, 13815 isInFor, 13816 isOnce 13817) { 13818 // render fns generated by compiler < 2.5.4 does not provide v-once 13819 // information to runtime so be conservative 13820 var isOldVersion = arguments.length < 3; 13821 // if a static tree is generated by v-once, it is cached on the instance; 13822 // otherwise it is purely static and can be cached on the shared options 13823 // across all instances. 13824 var renderFns = this.$options.staticRenderFns; 13825 var cached = isOldVersion || isOnce 13826 ? (this._staticTrees || (this._staticTrees = [])) 13827 : (renderFns.cached || (renderFns.cached = [])); 13828 var tree = cached[index]; 13829 // if has already-rendered static tree and not inside v-for, 13830 // we can reuse the same tree by doing a shallow clone. 13831 if (tree && !isInFor) { 13832 return Array.isArray(tree) 13833 ? cloneVNodes(tree) 13834 : cloneVNode(tree) 13835 } 13836 // otherwise, render a fresh tree. 13837 tree = cached[index] = renderFns[index].call(this._renderProxy, null, this); 13838 markStatic(tree, ("__static__" + index), false); 13839 return tree 13840} 13841 13842/** 13843 * Runtime helper for v-once. 13844 * Effectively it means marking the node as static with a unique key. 13845 */ 13846function markOnce ( 13847 tree, 13848 index, 13849 key 13850) { 13851 markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true); 13852 return tree 13853} 13854 13855function markStatic ( 13856 tree, 13857 key, 13858 isOnce 13859) { 13860 if (Array.isArray(tree)) { 13861 for (var i = 0; i < tree.length; i++) { 13862 if (tree[i] && typeof tree[i] !== 'string') { 13863 markStaticNode(tree[i], (key + "_" + i), isOnce); 13864 } 13865 } 13866 } else { 13867 markStaticNode(tree, key, isOnce); 13868 } 13869} 13870 13871function markStaticNode (node, key, isOnce) { 13872 node.isStatic = true; 13873 node.key = key; 13874 node.isOnce = isOnce; 13875} 13876 13877/* */ 13878 13879function bindObjectListeners (data, value) { 13880 if (value) { 13881 if (!isPlainObject(value)) { 13882 process.env.NODE_ENV !== 'production' && warn( 13883 'v-on without argument expects an Object value', 13884 this 13885 ); 13886 } else { 13887 var on = data.on = data.on ? extend({}, data.on) : {}; 13888 for (var key in value) { 13889 var existing = on[key]; 13890 var ours = value[key]; 13891 on[key] = existing ? [].concat(existing, ours) : ours; 13892 } 13893 } 13894 } 13895 return data 13896} 13897 13898/* */ 13899 13900function installRenderHelpers (target) { 13901 target._o = markOnce; 13902 target._n = toNumber; 13903 target._s = toString; 13904 target._l = renderList; 13905 target._t = renderSlot; 13906 target._q = looseEqual; 13907 target._i = looseIndexOf; 13908 target._m = renderStatic; 13909 target._f = resolveFilter; 13910 target._k = checkKeyCodes; 13911 target._b = bindObjectProps; 13912 target._v = createTextVNode; 13913 target._e = createEmptyVNode; 13914 target._u = resolveScopedSlots; 13915 target._g = bindObjectListeners; 13916} 13917 13918/* */ 13919 13920function FunctionalRenderContext ( 13921 data, 13922 props, 13923 children, 13924 parent, 13925 Ctor 13926) { 13927 var options = Ctor.options; 13928 this.data = data; 13929 this.props = props; 13930 this.children = children; 13931 this.parent = parent; 13932 this.listeners = data.on || emptyObject; 13933 this.injections = resolveInject(options.inject, parent); 13934 this.slots = function () { return resolveSlots(children, parent); }; 13935 13936 // ensure the createElement function in functional components 13937 // gets a unique context - this is necessary for correct named slot check 13938 var contextVm = Object.create(parent); 13939 var isCompiled = isTrue(options._compiled); 13940 var needNormalization = !isCompiled; 13941 13942 // support for compiled functional template 13943 if (isCompiled) { 13944 // exposing $options for renderStatic() 13945 this.$options = options; 13946 // pre-resolve slots for renderSlot() 13947 this.$slots = this.slots(); 13948 this.$scopedSlots = data.scopedSlots || emptyObject; 13949 } 13950 13951 if (options._scopeId) { 13952 this._c = function (a, b, c, d) { 13953 var vnode = createElement(contextVm, a, b, c, d, needNormalization); 13954 if (vnode) { 13955 vnode.functionalScopeId = options._scopeId; 13956 vnode.functionalContext = parent; 13957 } 13958 return vnode 13959 }; 13960 } else { 13961 this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); }; 13962 } 13963} 13964 13965installRenderHelpers(FunctionalRenderContext.prototype); 13966 13967function createFunctionalComponent ( 13968 Ctor, 13969 propsData, 13970 data, 13971 contextVm, 13972 children 13973) { 13974 var options = Ctor.options; 13975 var props = {}; 13976 var propOptions = options.props; 13977 if (isDef(propOptions)) { 13978 for (var key in propOptions) { 13979 props[key] = validateProp(key, propOptions, propsData || emptyObject); 13980 } 13981 } else { 13982 if (isDef(data.attrs)) { mergeProps(props, data.attrs); } 13983 if (isDef(data.props)) { mergeProps(props, data.props); } 13984 } 13985 13986 var renderContext = new FunctionalRenderContext( 13987 data, 13988 props, 13989 children, 13990 contextVm, 13991 Ctor 13992 ); 13993 13994 var vnode = options.render.call(null, renderContext._c, renderContext); 13995 13996 if (vnode instanceof VNode) { 13997 vnode.functionalContext = contextVm; 13998 vnode.functionalOptions = options; 13999 if (data.slot) { 14000 (vnode.data || (vnode.data = {})).slot = data.slot; 14001 } 14002 } 14003 14004 return vnode 14005} 14006 14007function mergeProps (to, from) { 14008 for (var key in from) { 14009 to[camelize(key)] = from[key]; 14010 } 14011} 14012 14013/* */ 14014 14015// hooks to be invoked on component VNodes during patch
vendor: 8,721 bytes, lines 14016-14321
14016var componentVNodeHooks = { 14017 init: function init ( 14018 vnode, 14019 hydrating, 14020 parentElm, 14021 refElm 14022 ) { 14023 if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) { 14024 var child = vnode.componentInstance = createComponentInstanceForVnode( 14025 vnode, 14026 activeInstance, 14027 parentElm, 14028 refElm 14029 ); 14030 child.$mount(hydrating ? vnode.elm : undefined, hydrating); 14031 } else if (vnode.data.keepAlive) { 14032 // kept-alive components, treat as a patch 14033 var mountedNode = vnode; // work around flow 14034 componentVNodeHooks.prepatch(mountedNode, mountedNode); 14035 } 14036 }, 14037 14038 prepatch: function prepatch (oldVnode, vnode) { 14039 var options = vnode.componentOptions; 14040 var child = vnode.componentInstance = oldVnode.componentInstance; 14041 updateChildComponent( 14042 child, 14043 options.propsData, // updated props 14044 options.listeners, // updated listeners 14045 vnode, // new parent vnode 14046 options.children // new children 14047 ); 14048 }, 14049 14050 insert: function insert (vnode) { 14051 var context = vnode.context; 14052 var componentInstance = vnode.componentInstance; 14053 if (!componentInstance._isMounted) { 14054 componentInstance._isMounted = true; 14055 callHook(componentInstance, 'mounted'); 14056 } 14057 if (vnode.data.keepAlive) { 14058 if (context._isMounted) { 14059 // vue-router#1212 14060 // During updates, a kept-alive component's child components may 14061 // change, so directly walking the tree here may call activated hooks 14062 // on incorrect children. Instead we push them into a queue which will 14063 // be processed after the whole patch process ended. 14064 queueActivatedComponent(componentInstance); 14065 } else { 14066 activateChildComponent(componentInstance, true /* direct */); 14067 } 14068 } 14069 }, 14070 14071 destroy: function destroy (vnode) { 14072 var componentInstance = vnode.componentInstance; 14073 if (!componentInstance._isDestroyed) { 14074 if (!vnode.data.keepAlive) { 14075 componentInstance.$destroy(); 14076 } else { 14077 deactivateChildComponent(componentInstance, true /* direct */); 14078 } 14079 } 14080 } 14081}; 14082 14083var hooksToMerge = Object.keys(componentVNodeHooks); 14084 14085function createComponent ( 14086 Ctor, 14087 data, 14088 context, 14089 children, 14090 tag 14091) { 14092 if (isUndef(Ctor)) { 14093 return 14094 } 14095 14096 var baseCtor = context.$options._base; 14097 14098 // plain options object: turn it into a constructor 14099 if (isObject(Ctor)) { 14100 Ctor = baseCtor.extend(Ctor); 14101 } 14102 14103 // if at this stage it's not a constructor or an async component factory, 14104 // reject. 14105 if (typeof Ctor !== 'function') { 14106 if (process.env.NODE_ENV !== 'production') { 14107 warn(("Invalid Component definition: " + (String(Ctor))), context); 14108 } 14109 return 14110 } 14111 14112 // async component 14113 var asyncFactory; 14114 if (isUndef(Ctor.cid)) { 14115 asyncFactory = Ctor; 14116 Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context); 14117 if (Ctor === undefined) { 14118 // return a placeholder node for async component, which is rendered 14119 // as a comment node but preserves all the raw information for the node. 14120 // the information will be used for async server-rendering and hydration. 14121 return createAsyncPlaceholder( 14122 asyncFactory, 14123 data, 14124 context, 14125 children, 14126 tag 14127 ) 14128 } 14129 } 14130 14131 data = data || {}; 14132 14133 // resolve constructor options in case global mixins are applied after 14134 // component constructor creation 14135 resolveConstructorOptions(Ctor); 14136 14137 // transform component v-model data into props & events 14138 if (isDef(data.model)) { 14139 transformModel(Ctor.options, data); 14140 } 14141 14142 // extract props 14143 var propsData = extractPropsFromVNodeData(data, Ctor, tag); 14144 14145 // functional component 14146 if (isTrue(Ctor.options.functional)) { 14147 return createFunctionalComponent(Ctor, propsData, data, context, children) 14148 } 14149 14150 // extract listeners, since these needs to be treated as 14151 // child component listeners instead of DOM listeners 14152 var listeners = data.on; 14153 // replace with listeners with .native modifier 14154 // so it gets processed during parent component patch. 14155 data.on = data.nativeOn; 14156 14157 if (isTrue(Ctor.options.abstract)) { 14158 // abstract components do not keep anything 14159 // other than props & listeners & slot 14160 14161 // work around flow 14162 var slot = data.slot; 14163 data = {}; 14164 if (slot) { 14165 data.slot = slot; 14166 } 14167 } 14168 14169 // merge component management hooks onto the placeholder node 14170 mergeHooks(data); 14171 14172 // return a placeholder vnode 14173 var name = Ctor.options.name || tag; 14174 var vnode = new VNode( 14175 ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), 14176 data, undefined, undefined, undefined, context, 14177 { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, 14178 asyncFactory 14179 ); 14180 return vnode 14181} 14182 14183function createComponentInstanceForVnode ( 14184 vnode, // we know it's MountedComponentVNode but flow doesn't 14185 parent, // activeInstance in lifecycle state 14186 parentElm, 14187 refElm 14188) { 14189 var vnodeComponentOptions = vnode.componentOptions; 14190 var options = { 14191 _isComponent: true, 14192 parent: parent, 14193 propsData: vnodeComponentOptions.propsData, 14194 _componentTag: vnodeComponentOptions.tag, 14195 _parentVnode: vnode, 14196 _parentListeners: vnodeComponentOptions.listeners, 14197 _renderChildren: vnodeComponentOptions.children, 14198 _parentElm: parentElm || null, 14199 _refElm: refElm || null 14200 }; 14201 // check inline-template render functions 14202 var inlineTemplate = vnode.data.inlineTemplate; 14203 if (isDef(inlineTemplate)) { 14204 options.render = inlineTemplate.render; 14205 options.staticRenderFns = inlineTemplate.staticRenderFns; 14206 } 14207 return new vnodeComponentOptions.Ctor(options) 14208} 14209 14210function mergeHooks (data) { 14211 if (!data.hook) { 14212 data.hook = {}; 14213 } 14214 for (var i = 0; i < hooksToMerge.length; i++) { 14215 var key = hooksToMerge[i]; 14216 var fromParent = data.hook[key]; 14217 var ours = componentVNodeHooks[key]; 14218 data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours; 14219 } 14220} 14221 14222function mergeHook$1 (one, two) { 14223 return function (a, b, c, d) { 14224 one(a, b, c, d); 14225 two(a, b, c, d); 14226 } 14227} 14228 14229// transform component v-model info (value and callback) into 14230// prop and event handler respectively. 14231function transformModel (options, data) { 14232 var prop = (options.model && options.model.prop) || 'value'; 14233 var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value; 14234 var on = data.on || (data.on = {}); 14235 if (isDef(on[event])) { 14236 on[event] = [data.model.callback].concat(on[event]); 14237 } else { 14238 on[event] = data.model.callback; 14239 } 14240} 14241 14242/* */ 14243 14244var SIMPLE_NORMALIZE = 1; 14245var ALWAYS_NORMALIZE = 2; 14246 14247// wrapper function for providing a more flexible interface 14248// without getting yelled at by flow 14249function createElement ( 14250 context, 14251 tag, 14252 data, 14253 children, 14254 normalizationType, 14255 alwaysNormalize 14256) { 14257 if (Array.isArray(data) || isPrimitive(data)) { 14258 normalizationType = children; 14259 children = data; 14260 data = undefined; 14261 } 14262 if (isTrue(alwaysNormalize)) { 14263 normalizationType = ALWAYS_NORMALIZE; 14264 } 14265 return _createElement(context, tag, data, children, normalizationType) 14266} 14267 14268function _createElement ( 14269 context, 14270 tag, 14271 data, 14272 children, 14273 normalizationType 14274) { 14275 if (isDef(data) && isDef((data).__ob__)) { 14276 process.env.NODE_ENV !== 'production' && warn( 14277 "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 14278 'Always create fresh vnode data objects in each render!', 14279 context 14280 ); 14281 return createEmptyVNode() 14282 } 14283 // object syntax in v-bind 14284 if (isDef(data) && isDef(data.is)) { 14285 tag = data.is; 14286 } 14287 if (!tag) { 14288 // in case of component :is set to falsy value 14289 return createEmptyVNode() 14290 } 14291 // warn against non-primitive key 14292 if (process.env.NODE_ENV !== 'production' && 14293 isDef(data) && isDef(data.key) && !isPrimitive(data.key) 14294 ) { 14295 warn( 14296 'Avoid using non-primitive value as key, ' + 14297 'use string/number value instead.', 14298 context 14299 ); 14300 } 14301 // support single function children as default scoped slot 14302 if (Array.isArray(children) && 14303 typeof children[0] === 'function' 14304 ) { 14305 data = data || {}; 14306 data.scopedSlots = { default: children[0] }; 14307 children.length = 0; 14308 } 14309 if (normalizationType === ALWAYS_NORMALIZE) { 14310 children = normalizeChildren(children); 14311 } else if (normalizationType === SIMPLE_NORMALIZE) { 14312 children = simpleNormalizeChildren(children); 14313 } 14314 var vnode, ns; 14315 if (typeof tag === 'string') { 14316 var Ctor; 14317 ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag); 14318 if (config.isReservedTag(tag)) { 14319 // platform built-in elements 14320 vnode = new VNode( 14321 config.parsePlatformTagName(tag), data, children,
14322 undefined, undefined, context 14323 ); 14324 } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) { 14325 // component 14326 vnode = createComponent(Ctor, data, context, children, tag); 14327 } else { 14328 // unknown or unlisted namespaced elements 14329 // check at runtime because it may get assigned a namespace when its 14330 // parent normalizes children 14331 vnode = new VNode( 14332 tag, data, children, 14333 undefined, undefined, context 14334 ); 14335 } 14336 } else { 14337 // direct component options / constructor 14338 vnode = createComponent(tag, data, context, children); 14339 } 14340 if (isDef(vnode)) { 14341 if (ns) { applyNS(vnode, ns); } 14342 return vnode 14343 } else { 14344 return createEmptyVNode() 14345 } 14346} 14347 14348function applyNS (vnode, ns, force) { 14349 vnode.ns = ns; 14350 if (vnode.tag === 'foreignObject') { 14351 // use default namespace inside foreignObject 14352 ns = undefined; 14353 force = true; 14354 } 14355 if (isDef(vnode.children)) { 14356 for (var i = 0, l = vnode.children.length; i < l; i++) { 14357 var child = vnode.children[i]; 14358 if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) { 14359 applyNS(child, ns, force); 14360 } 14361 } 14362 } 14363} 14364 14365/* */ 14366 14367function initRender (vm) { 14368 vm._vnode = null; // the root of the child tree 14369 vm._staticTrees = null; // v-once cached trees 14370 var options = vm.$options; 14371 var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree 14372 var renderContext = parentVnode && parentVnode.context; 14373 vm.$slots = resolveSlots(options._renderChildren, renderContext); 14374 vm.$scopedSlots = emptyObject; 14375 // bind the createElement fn to this instance 14376 // so that we get proper render context inside it. 14377 // args order: tag, data, children, normalizationType, alwaysNormalize 14378 // internal version is used by render functions compiled from templates 14379 vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); }; 14380 // normalization is always applied for the public version, used in 14381 // user-written render functions. 14382 vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); }; 14383 14384 // $attrs & $listeners are exposed for easier HOC creation. 14385 // they need to be reactive so that HOCs using them are always updated 14386 var parentData = parentVnode && parentVnode.data; 14387 14388 /* istanbul ignore else */ 14389 if (process.env.NODE_ENV !== 'production') { 14390 defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () { 14391 !isUpdatingChildComponent && warn("$attrs is readonly.", vm); 14392 }, true); 14393 defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () { 14394 !isUpdatingChildComponent && warn("$listeners is readonly.", vm); 14395 }, true); 14396 } else { 14397 defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true); 14398 defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true); 14399 } 14400} 14401 14402function renderMixin (Vue) { 14403 // install runtime convenience helpers 14404 installRenderHelpers(Vue.prototype); 14405 14406 Vue.prototype.$nextTick = function (fn) { 14407 return nextTick(fn, this) 14408 }; 14409 14410 Vue.prototype._render = function () { 14411 var vm = this; 14412 var ref = vm.$options; 14413 var render = ref.render; 14414 var _parentVnode = ref._parentVnode; 14415 14416 if (vm._isMounted) { 14417 // if the parent didn't update, the slot nodes will be the ones from 14418 // last render. They need to be cloned to ensure "freshness" for this render. 14419 for (var key in vm.$slots) { 14420 var slot = vm.$slots[key]; 14421 // _rendered is a flag added by renderSlot, but may not be present 14422 // if the slot is passed from manually written render functions 14423 if (slot._rendered || (slot[0] && slot[0].elm)) { 14424 vm.$slots[key] = cloneVNodes(slot, true /* deep */); 14425 } 14426 } 14427 } 14428 14429 vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject; 14430 14431 // set parent vnode. this allows render functions to have access 14432 // to the data on the placeholder node. 14433 vm.$vnode = _parentVnode; 14434 // render self 14435 var vnode; 14436 try { 14437 vnode = render.call(vm._renderProxy, vm.$createElement); 14438 } catch (e) { 14439 handleError(e, vm, "render"); 14440 // return error render result, 14441 // or previous vnode to prevent render error causing blank component 14442 /* istanbul ignore else */ 14443 if (process.env.NODE_ENV !== 'production') { 14444 if (vm.$options.renderError) { 14445 try { 14446 vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e); 14447 } catch (e) { 14448 handleError(e, vm, "renderError"); 14449 vnode = vm._vnode; 14450 } 14451 } else { 14452 vnode = vm._vnode; 14453 } 14454 } else { 14455 vnode = vm._vnode; 14456 } 14457 } 14458 // return empty vnode in case the render function errored out 14459 if (!(vnode instanceof VNode)) { 14460 if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) { 14461 warn( 14462 'Multiple root nodes returned from render function. Render function ' + 14463 'should return a single root node.', 14464 vm 14465 ); 14466 } 14467 vnode = createEmptyVNode(); 14468 } 14469 // set parent 14470 vnode.parent = _parentVnode; 14471 return vnode 14472 }; 14473} 14474 14475/* */ 14476 14477var uid$1 = 0; 14478 14479function initMixin (Vue) { 14480 Vue.prototype._init = function (options) { 14481 var vm = this; 14482 // a uid 14483 vm._uid = uid$1++; 14484 14485 var startTag, endTag; 14486 /* istanbul ignore if */ 14487 if (process.env.NODE_ENV !== 'production' && config.performance && mark) { 14488 startTag = "vue-perf-start:" + (vm._uid); 14489 endTag = "vue-perf-end:" + (vm._uid); 14490 mark(startTag); 14491 } 14492 14493 // a flag to avoid this being observed 14494 vm._isVue = true; 14495 // merge options 14496 if (options && options._isComponent) {
14497 // optimize internal component instantiation 14498 // since dynamic options merging is pretty slow, and none of the 14499 // internal component options needs special treatment. 14500 initInternalComponent(vm, options); 14501 } else { 14502 vm.$options = mergeOptions( 14503 resolveConstructorOptions(vm.constructor), 14504 options || {}, 14505 vm 14506 ); 14507 } 14508 /* istanbul ignore else */ 14509 if (process.env.NODE_ENV !== 'production') { 14510 initProxy(vm); 14511 } else { 14512 vm._renderProxy = vm; 14513 } 14514 // expose real self 14515 vm._self = vm; 14516 initLifecycle(vm); 14517 initEvents(vm); 14518 initRender(vm); 14519 callHook(vm, 'beforeCreate'); 14520 initInjections(vm); // resolve injections before data/props 14521 initState(vm); 14522 initProvide(vm); // resolve provide after data/props 14523 callHook(vm, 'created'); 14524 14525 /* istanbul ignore if */ 14526 if (process.env.NODE_ENV !== 'production' && config.performance && mark) { 14527 vm._name = formatComponentName(vm, false); 14528 mark(endTag); 14529 measure(("vue " +
vendor: 7,251 bytes, lines 14529-14794
14529(vm._name) + " init"), startTag, endTag); 14530 } 14531 14532 if (vm.$options.el) { 14533 vm.$mount(vm.$options.el); 14534 } 14535 }; 14536} 14537 14538function initInternalComponent (vm, options) { 14539 var opts = vm.$options = Object.create(vm.constructor.options); 14540 // doing this because it's faster than dynamic enumeration. 14541 opts.parent = options.parent; 14542 opts.propsData = options.propsData; 14543 opts._parentVnode = options._parentVnode; 14544 opts._parentListeners = options._parentListeners; 14545 opts._renderChildren = options._renderChildren; 14546 opts._componentTag = options._componentTag; 14547 opts._parentElm = options._parentElm; 14548 opts._refElm = options._refElm; 14549 if (options.render) { 14550 opts.render = options.render; 14551 opts.staticRenderFns = options.staticRenderFns; 14552 } 14553} 14554 14555function resolveConstructorOptions (Ctor) { 14556 var options = Ctor.options; 14557 if (Ctor.super) { 14558 var superOptions = resolveConstructorOptions(Ctor.super); 14559 var cachedSuperOptions = Ctor.superOptions; 14560 if (superOptions !== cachedSuperOptions) { 14561 // super option changed, 14562 // need to resolve new options. 14563 Ctor.superOptions = superOptions; 14564 // check if there are any late-modified/attached options (#4976) 14565 var modifiedOptions = resolveModifiedOptions(Ctor); 14566 // update base extend options 14567 if (modifiedOptions) { 14568 extend(Ctor.extendOptions, modifiedOptions); 14569 } 14570 options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); 14571 if (options.name) { 14572 options.components[options.name] = Ctor; 14573 } 14574 } 14575 } 14576 return options 14577} 14578 14579function resolveModifiedOptions (Ctor) { 14580 var modified; 14581 var latest = Ctor.options; 14582 var extended = Ctor.extendOptions; 14583 var sealed = Ctor.sealedOptions; 14584 for (var key in latest) { 14585 if (latest[key] !== sealed[key]) { 14586 if (!modified) { modified = {}; } 14587 modified[key] = dedupe(latest[key], extended[key], sealed[key]); 14588 } 14589 } 14590 return modified 14591} 14592 14593function dedupe (latest, extended, sealed) { 14594 // compare latest and sealed to ensure lifecycle hooks won't be duplicated 14595 // between merges 14596 if (Array.isArray(latest)) { 14597 var res = []; 14598 sealed = Array.isArray(sealed) ? sealed : [sealed]; 14599 extended = Array.isArray(extended) ? extended : [extended]; 14600 for (var i = 0; i < latest.length; i++) { 14601 // push original options and not sealed options to exclude duplicated options 14602 if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) { 14603 res.push(latest[i]); 14604 } 14605 } 14606 return res 14607 } else { 14608 return latest 14609 } 14610} 14611 14612function Vue$3 (options) { 14613 if (process.env.NODE_ENV !== 'production' && 14614 !(this instanceof Vue$3) 14615 ) { 14616 warn('Vue is a constructor and should be called with the `new` keyword'); 14617 } 14618 this._init(options); 14619} 14620 14621initMixin(Vue$3); 14622stateMixin(Vue$3); 14623eventsMixin(Vue$3); 14624lifecycleMixin(Vue$3); 14625renderMixin(Vue$3); 14626 14627/* */ 14628 14629function initUse (Vue) { 14630 Vue.use = function (plugin) { 14631 var installedPlugins = (this._installedPlugins || (this._installedPlugins = [])); 14632 if (installedPlugins.indexOf(plugin) > -1) { 14633 return this 14634 } 14635 14636 // additional parameters 14637 var args = toArray(arguments, 1); 14638 args.unshift(this); 14639 if (typeof plugin.install === 'function') { 14640 plugin.install.apply(plugin, args); 14641 } else if (typeof plugin === 'function') { 14642 plugin.apply(null, args); 14643 } 14644 installedPlugins.push(plugin); 14645 return this 14646 }; 14647} 14648 14649/* */ 14650 14651function initMixin$1 (Vue) { 14652 Vue.mixin = function (mixin) { 14653 this.options = mergeOptions(this.options, mixin); 14654 return this 14655 }; 14656} 14657 14658/* */ 14659 14660function initExtend (Vue) { 14661 /** 14662 * Each instance constructor, including Vue, has a unique 14663 * cid. This enables us to create wrapped "child 14664 * constructors" for prototypal inheritance and cache them. 14665 */ 14666 Vue.cid = 0; 14667 var cid = 1; 14668 14669 /** 14670 * Class inheritance 14671 */ 14672 Vue.extend = function (extendOptions) { 14673 extendOptions = extendOptions || {}; 14674 var Super = this; 14675 var SuperId = Super.cid; 14676 var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); 14677 if (cachedCtors[SuperId]) { 14678 return cachedCtors[SuperId] 14679 } 14680 14681 var name = extendOptions.name || Super.options.name; 14682 if (process.env.NODE_ENV !== 'production') { 14683 if (!/^[a-zA-Z][\w-]*$/.test(name)) { 14684 warn( 14685 'Invalid component name: "' + name + '". Component names ' + 14686 'can only contain alphanumeric characters and the hyphen, ' + 14687 'and must start with a letter.' 14688 ); 14689 } 14690 } 14691 14692 var Sub = function VueComponent (options) { 14693 this._init(options); 14694 }; 14695 Sub.prototype = Object.create(Super.prototype); 14696 Sub.prototype.constructor = Sub; 14697 Sub.cid = cid++; 14698 Sub.options = mergeOptions( 14699 Super.options, 14700 extendOptions 14701 ); 14702 Sub['super'] = Super; 14703 14704 // For props and computed properties, we define the proxy getters on 14705 // the Vue instances at extension time, on the extended prototype. This 14706 // avoids Object.defineProperty calls for each instance created. 14707 if (Sub.options.props) { 14708 initProps$1(Sub); 14709 } 14710 if (Sub.options.computed) { 14711 initComputed$1(Sub); 14712 } 14713 14714 // allow further extension/mixin/plugin usage 14715 Sub.extend = Super.extend; 14716 Sub.mixin = Super.mixin; 14717 Sub.use = Super.use; 14718 14719 // create asset registers, so extended classes 14720 // can have their private assets too. 14721 ASSET_TYPES.forEach(function (type) { 14722 Sub[type] = Super[type]; 14723 }); 14724 // enable recursive self-lookup 14725 if (name) { 14726 Sub.options.components[name] = Sub; 14727 } 14728 14729 // keep a reference to the super options at extension time. 14730 // later at instantiation we can check if Super's options have 14731 // been updated. 14732 Sub.superOptions = Super.options; 14733 Sub.extendOptions = extendOptions; 14734 Sub.sealedOptions = extend({}, Sub.options); 14735 14736 // cache constructor 14737 cachedCtors[SuperId] = Sub; 14738 return Sub 14739 }; 14740} 14741 14742function initProps$1 (Comp) { 14743 var props = Comp.options.props; 14744 for (var key in props) { 14745 proxy(Comp.prototype, "_props", key); 14746 } 14747} 14748 14749function initComputed$1 (Comp) { 14750 var computed = Comp.options.computed; 14751 for (var key in computed) { 14752 defineComputed(Comp.prototype, key, computed[key]); 14753 } 14754} 14755 14756/* */ 14757 14758function initAssetRegisters (Vue) { 14759 /** 14760 * Create asset registration methods. 14761 */ 14762 ASSET_TYPES.forEach(function (type) { 14763 Vue[type] = function ( 14764 id, 14765 definition 14766 ) { 14767 if (!definition) { 14768 return this.options[type + 's'][id] 14769 } else { 14770 /* istanbul ignore if */ 14771 if (process.env.NODE_ENV !== 'production') { 14772 if (type === 'component' && config.isReservedTag(id)) { 14773 warn( 14774 'Do not use built-in or reserved HTML elements as component ' + 14775 'id: ' + id 14776 ); 14777 } 14778 } 14779 if (type === 'component' && isPlainObject(definition)) { 14780 definition.name = definition.name || id; 14781 definition = this.options._base.extend(definition); 14782 } 14783 if (type === 'directive' && typeof definition === 'function') { 14784 definition = { bind: definition, update: definition }; 14785 } 14786 this.options[type + 's'][id] = definition; 14787 return definition 14788 } 14789 }; 14790 }); 14791} 14792 14793/* */ 14794
14795function getComponentName (opts) { 14796 return opts && (opts.Ctor.options.name || opts.tag) 14797} 14798 14799function matches (pattern, name) { 14800 if (Array.isArray(pattern)) { 14801 return pattern.indexOf(name) > -1 14802 } else if (typeof pattern === 'string') { 14803 return pattern.split(',').indexOf(name) > -1 14804 } else if (isRegExp(pattern)) { 14805 return pattern.test(name) 14806 } 14807 /* istanbul ignore next */ 14808 return false 14809} 14810 14811function pruneCache (keepAliveInstance, filter) { 14812 var cache = keepAliveInstance.cache; 14813 var keys = keepAliveInstance.keys; 14814 var _vnode = keepAliveInstance._vnode; 14815 for (var key in cache) { 14816 var cachedNode = cache[key]; 14817 if (cachedNode) { 14818 var name = getComponentName(cachedNode.componentOptions); 14819 if (name && !filter(name)) { 14820 pruneCacheEntry(cache, key, keys, _vnode); 14821 } 14822 } 14823 } 14824} 14825 14826function pruneCacheEntry ( 14827 cache, 14828 key, 14829 keys, 14830 current 14831) { 14832 var cached$$1 = cache[key]; 14833 if (cached$$1 && cached$$1 !== current) { 14834 cached$$1.componentInstance.$destroy(); 14835 } 14836 cache[key] = null; 14837 remove(keys, key); 14838} 14839 14840var patternTypes = [String, RegExp, Array]; 14841 14842var KeepAlive = { 14843 name: 'keep-alive', 14844 abstract: true, 14845 14846 props: { 14847 include: patternTypes, 14848 exclude: patternTypes, 14849 max: [String, Number] 14850 }, 14851 14852 created: function created () { 14853 this.cache = Object.create(null); 14854 this.keys = []; 14855 }, 14856 14857 destroyed: function destroyed () { 14858 var this$1 = this; 14859 14860 for (var key in this$1.cache) { 14861 pruneCacheEntry(this$1.cache, key, this$1.keys); 14862 } 14863 }, 14864 14865 watch: { 14866 include: function include (val) { 14867 pruneCache(this, function (name) { return matches(val, name); }); 14868 }, 14869 exclude: function exclude (val) { 14870 pruneCache(this, function (name) { return !matches(val, name); }); 14871 } 14872 }, 14873 14874 render: function render () { 14875 var slot = this.$slots.default; 14876 var vnode = getFirstComponentChild(slot); 14877 var componentOptions = vnode && vnode.componentOptions; 14878 if (componentOptions) { 14879 // check pattern 14880 var name = getComponentName(componentOptions); 14881 var ref = this; 14882 var include = ref.include; 14883 var exclude = ref.exclude; 14884 if ( 14885 // not included 14886 (include && (!name || !matches(include, name))) || 14887 // excluded 14888 (exclude && name && matches(exclude, name)) 14889 ) { 14890 return vnode 14891 } 14892 14893 var ref$1 = this; 14894 var cache = ref$1.cache; 14895 var keys = ref$1.keys; 14896 var key = vnode.key == null 14897 // same constructor may get registered as different local components 14898 // so cid alone is not enough (#3269) 14899 ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '') 14900 : vnode.key; 14901 if (cache[key]) {
vendor: 10,882 bytes, lines 14902-15339
14902 vnode.componentInstance = cache[key].componentInstance; 14903 // make current key freshest 14904 remove(keys, key); 14905 keys.push(key); 14906 } else { 14907 cache[key] = vnode; 14908 keys.push(key); 14909 // prune oldest entry 14910 if (this.max && keys.length > parseInt(this.max)) { 14911 pruneCacheEntry(cache, keys[0], keys, this._vnode); 14912 } 14913 } 14914 14915 vnode.data.keepAlive = true; 14916 } 14917 return vnode || (slot && slot[0]) 14918 } 14919}; 14920 14921var builtInComponents = { 14922 KeepAlive: KeepAlive 14923}; 14924 14925/* */ 14926 14927function initGlobalAPI (Vue) { 14928 // config 14929 var configDef = {}; 14930 configDef.get = function () { return config; }; 14931 if (process.env.NODE_ENV !== 'production') { 14932 configDef.set = function () { 14933 warn( 14934 'Do not replace the Vue.config object, set individual fields instead.' 14935 ); 14936 }; 14937 } 14938 Object.defineProperty(Vue, 'config', configDef); 14939 14940 // exposed util methods. 14941 // NOTE: these are not considered part of the public API - avoid relying on 14942 // them unless you are aware of the risk. 14943 Vue.util = { 14944 warn: warn, 14945 extend: extend, 14946 mergeOptions: mergeOptions, 14947 defineReactive: defineReactive 14948 }; 14949 14950 Vue.set = set; 14951 Vue.delete = del; 14952 Vue.nextTick = nextTick; 14953 14954 Vue.options = Object.create(null); 14955 ASSET_TYPES.forEach(function (type) { 14956 Vue.options[type + 's'] = Object.create(null); 14957 }); 14958 14959 // this is used to identify the "base" constructor to extend all plain-object 14960 // components with in Weex's multi-instance scenarios. 14961 Vue.options._base = Vue; 14962 14963 extend(Vue.options.components, builtInComponents); 14964 14965 initUse(Vue); 14966 initMixin$1(Vue); 14967 initExtend(Vue); 14968 initAssetRegisters(Vue); 14969} 14970 14971initGlobalAPI(Vue$3); 14972 14973Object.defineProperty(Vue$3.prototype, '$isServer', { 14974 get: isServerRendering 14975}); 14976 14977Object.defineProperty(Vue$3.prototype, '$ssrContext', { 14978 get: function get () { 14979 /* istanbul ignore next */ 14980 return this.$vnode && this.$vnode.ssrContext 14981 } 14982}); 14983 14984Vue$3.version = '2.5.8'; 14985 14986/* */ 14987 14988// these are reserved for web because they are directly compiled away 14989// during template compilation 14990var isReservedAttr = makeMap('style,class'); 14991 14992// attributes that should be using props for binding 14993var acceptValue = makeMap('input,textarea,option,select,progress'); 14994var mustUseProp = function (tag, type, attr) { 14995 return ( 14996 (attr === 'value' && acceptValue(tag)) && type !== 'button' || 14997 (attr === 'selected' && tag === 'option') || 14998 (attr === 'checked' && tag === 'input') || 14999 (attr === 'muted' && tag === 'video') 15000 ) 15001}; 15002 15003var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); 15004 15005var isBooleanAttr = makeMap( 15006 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 15007 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 15008 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 15009 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 15010 'required,reversed,scoped,seamless,selected,sortable,translate,' + 15011 'truespeed,typemustmatch,visible' 15012); 15013 15014var xlinkNS = 'http://www.w3.org/1999/xlink'; 15015 15016var isXlink = function (name) { 15017 return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' 15018}; 15019 15020var getXlinkProp = function (name) { 15021 return isXlink(name) ? name.slice(6, name.length) : '' 15022}; 15023 15024var isFalsyAttrValue = function (val) { 15025 return val == null || val === false 15026}; 15027 15028/* */ 15029 15030function genClassForVnode (vnode) { 15031 var data = vnode.data; 15032 var parentNode = vnode; 15033 var childNode = vnode; 15034 while (isDef(childNode.componentInstance)) { 15035 childNode = childNode.componentInstance._vnode; 15036 if (childNode.data) { 15037 data = mergeClassData(childNode.data, data); 15038 } 15039 } 15040 while (isDef(parentNode = parentNode.parent)) { 15041 if (parentNode.data) { 15042 data = mergeClassData(data, parentNode.data); 15043 } 15044 } 15045 return renderClass(data.staticClass, data.class) 15046} 15047 15048function mergeClassData (child, parent) { 15049 return { 15050 staticClass: concat(child.staticClass, parent.staticClass), 15051 class: isDef(child.class) 15052 ? [child.class, parent.class] 15053 : parent.class 15054 } 15055} 15056 15057function renderClass ( 15058 staticClass, 15059 dynamicClass 15060) { 15061 if (isDef(staticClass) || isDef(dynamicClass)) { 15062 return concat(staticClass, stringifyClass(dynamicClass)) 15063 } 15064 /* istanbul ignore next */ 15065 return '' 15066} 15067 15068function concat (a, b) { 15069 return a ? b ? (a + ' ' + b) : a : (b || '') 15070} 15071 15072function stringifyClass (value) { 15073 if (Array.isArray(value)) { 15074 return stringifyArray(value) 15075 } 15076 if (isObject(value)) { 15077 return stringifyObject(value) 15078 } 15079 if (typeof value === 'string') { 15080 return value 15081 } 15082 /* istanbul ignore next */ 15083 return '' 15084} 15085 15086function stringifyArray (value) { 15087 var res = ''; 15088 var stringified; 15089 for (var i = 0, l = value.length; i < l; i++) { 15090 if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') { 15091 if (res) { res += ' '; } 15092 res += stringified; 15093 } 15094 } 15095 return res 15096} 15097 15098function stringifyObject (value) { 15099 var res = ''; 15100 for (var key in value) { 15101 if (value[key]) { 15102 if (res) { res += ' '; } 15103 res += key; 15104 } 15105 } 15106 return res 15107} 15108 15109/* */ 15110 15111var namespaceMap = { 15112 svg: 'http://www.w3.org/2000/svg', 15113 math: 'http://www.w3.org/1998/Math/MathML' 15114}; 15115 15116var isHTMLTag = makeMap( 15117 'html,body,base,head,link,meta,style,title,' + 15118 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 15119 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 15120 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 15121 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 15122 'embed,object,param,source,canvas,script,noscript,del,ins,' + 15123 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 15124 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 15125 'output,progress,select,textarea,' + 15126 'details,dialog,menu,menuitem,summary,' + 15127 'content,element,shadow,template,blockquote,iframe,tfoot' 15128); 15129 15130// this map is intentionally selective, only covering SVG elements that may 15131// contain child elements. 15132var isSVG = makeMap( 15133 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 15134 'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 15135 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', 15136 true 15137); 15138 15139var isPreTag = function (tag) { return tag === 'pre'; }; 15140 15141var isReservedTag = function (tag) { 15142 return isHTMLTag(tag) || isSVG(tag) 15143}; 15144 15145function getTagNamespace (tag) { 15146 if (isSVG(tag)) { 15147 return 'svg' 15148 } 15149 // basic support for MathML 15150 // note it doesn't support other MathML elements being component roots 15151 if (tag === 'math') { 15152 return 'math' 15153 } 15154} 15155 15156var unknownElementCache = Object.create(null); 15157function isUnknownElement (tag) { 15158 /* istanbul ignore if */ 15159 if (!inBrowser) { 15160 return true 15161 } 15162 if (isReservedTag(tag)) { 15163 return false 15164 } 15165 tag = tag.toLowerCase(); 15166 /* istanbul ignore if */ 15167 if (unknownElementCache[tag] != null) { 15168 return unknownElementCache[tag] 15169 } 15170 var el = document.createElement(tag); 15171 if (tag.indexOf('-') > -1) { 15172 // http://stackoverflow.com/a/28210364/1070244 15173 return (unknownElementCache[tag] = ( 15174 el.constructor === window.HTMLUnknownElement || 15175 el.constructor === window.HTMLElement 15176 )) 15177 } else { 15178 return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) 15179 } 15180} 15181 15182var isTextInputType = makeMap('text,number,password,search,email,tel,url'); 15183 15184/* */ 15185 15186/** 15187 * Query an element selector if it's not an element already. 15188 */ 15189function query (el) { 15190 if (typeof el === 'string') { 15191 var selected = document.querySelector(el); 15192 if (!selected) { 15193 process.env.NODE_ENV !== 'production' && warn( 15194 'Cannot find element: ' + el 15195 ); 15196 return document.createElement('div') 15197 } 15198 return selected 15199 } else { 15200 return el 15201 } 15202} 15203 15204/* */ 15205 15206function createElement$1 (tagName, vnode) { 15207 var elm = document.createElement(tagName); 15208 if (tagName !== 'select') { 15209 return elm 15210 } 15211 // false or null will remove the attribute but undefined will not 15212 if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) { 15213 elm.setAttribute('multiple', 'multiple'); 15214 } 15215 return elm 15216} 15217 15218function createElementNS (namespace, tagName) { 15219 return document.createElementNS(namespaceMap[namespace], tagName) 15220} 15221 15222function createTextNode (text) { 15223 return document.createTextNode(text) 15224} 15225 15226function createComment (text) { 15227 return document.createComment(text) 15228} 15229 15230function insertBefore (parentNode, newNode, referenceNode) { 15231 parentNode.insertBefore(newNode, referenceNode); 15232} 15233 15234function removeChild (node, child) { 15235 node.removeChild(child); 15236} 15237 15238function appendChild (node, child) { 15239 node.appendChild(child); 15240} 15241 15242function parentNode (node) { 15243 return node.parentNode 15244} 15245 15246function nextSibling (node) { 15247 return node.nextSibling 15248} 15249 15250function tagName (node) { 15251 return node.tagName 15252} 15253 15254function setTextContent (node, text) { 15255 node.textContent = text; 15256} 15257 15258function setAttribute (node, key, val) { 15259 node.setAttribute(key, val); 15260} 15261 15262 15263var nodeOps = Object.freeze({ 15264 createElement: createElement$1, 15265 createElementNS: createElementNS, 15266 createTextNode: createTextNode, 15267 createComment: createComment, 15268 insertBefore: insertBefore, 15269 removeChild: removeChild, 15270 appendChild: appendChild, 15271 parentNode: parentNode, 15272 nextSibling: nextSibling, 15273 tagName: tagName, 15274 setTextContent: setTextContent, 15275 setAttribute: setAttribute 15276}); 15277 15278/* */ 15279 15280var ref = { 15281 create: function create (_, vnode) { 15282 registerRef(vnode); 15283 }, 15284 update: function update (oldVnode, vnode) { 15285 if (oldVnode.data.ref !== vnode.data.ref) { 15286 registerRef(oldVnode, true); 15287 registerRef(vnode); 15288 } 15289 }, 15290 destroy: function destroy (vnode) { 15291 registerRef(vnode, true); 15292 } 15293}; 15294 15295function registerRef (vnode, isRemoval) { 15296 var key = vnode.data.ref; 15297 if (!key) { return } 15298 15299 var vm = vnode.context; 15300 var ref = vnode.componentInstance || vnode.elm; 15301 var refs = vm.$refs; 15302 if (isRemoval) { 15303 if (Array.isArray(refs[key])) { 15304 remove(refs[key], ref); 15305 } else if (refs[key] === ref) { 15306 refs[key] = undefined; 15307 } 15308 } else { 15309 if (vnode.data.refInFor) { 15310 if (!Array.isArray(refs[key])) { 15311 refs[key] = [ref]; 15312 } else if (refs[key].indexOf(ref) < 0) { 15313 // $flow-disable-line 15314 refs[key].push(ref); 15315 } 15316 } else { 15317 refs[key] = ref; 15318 } 15319 } 15320} 15321 15322/** 15323 * Virtual DOM patching algorithm based on Snabbdom by 15324 * Simon Friis Vindum (@paldepind) 15325 * Licensed under the MIT License 15326 * https://github.com/paldepind/snabbdom/blob/master/LICENSE 15327 * 15328 * modified by Evan You (@yyx990803) 15329 * 15330 * Not type-checking this because this file is perf-critical and the cost 15331 * of making flow understand it is not worth it. 15332 */ 15333 15334var emptyNode = new VNode('', {}, []); 15335 15336var hooks = ['create', 'activate', 'update', 'remove', 'destroy']; 15337 15338function sameVnode (a, b) { 15339 return (
vendor: 13,852 bytes, lines 15340-15756
15340 a.key === b.key && ( 15341 ( 15342 a.tag === b.tag && 15343 a.isComment === b.isComment && 15344 isDef(a.data) === isDef(b.data) && 15345 sameInputType(a, b) 15346 ) || ( 15347 isTrue(a.isAsyncPlaceholder) && 15348 a.asyncFactory === b.asyncFactory && 15349 isUndef(b.asyncFactory.error) 15350 ) 15351 ) 15352 ) 15353} 15354 15355function sameInputType (a, b) { 15356 if (a.tag !== 'input') { return true } 15357 var i; 15358 var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; 15359 var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; 15360 return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB) 15361} 15362 15363function createKeyToOldIdx (children, beginIdx, endIdx) { 15364 var i, key; 15365 var map = {}; 15366 for (i = beginIdx; i <= endIdx; ++i) { 15367 key = children[i].key; 15368 if (isDef(key)) { map[key] = i; } 15369 } 15370 return map 15371} 15372 15373function createPatchFunction (backend) { 15374 var i, j; 15375 var cbs = {}; 15376 15377 var modules = backend.modules; 15378 var nodeOps = backend.nodeOps; 15379 15380 for (i = 0; i < hooks.length; ++i) { 15381 cbs[hooks[i]] = []; 15382 for (j = 0; j < modules.length; ++j) { 15383 if (isDef(modules[j][hooks[i]])) { 15384 cbs[hooks[i]].push(modules[j][hooks[i]]); 15385 } 15386 } 15387 } 15388 15389 function emptyNodeAt (elm) { 15390 return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm) 15391 } 15392 15393 function createRmCb (childElm, listeners) { 15394 function remove () { 15395 if (--remove.listeners === 0) { 15396 removeNode(childElm); 15397 } 15398 } 15399 remove.listeners = listeners; 15400 return remove 15401 } 15402 15403 function removeNode (el) { 15404 var parent = nodeOps.parentNode(el); 15405 // element may have already been removed due to v-html / v-text 15406 if (isDef(parent)) { 15407 nodeOps.removeChild(parent, el); 15408 } 15409 } 15410 15411 function isUnknownElement$$1 (vnode, inVPre) { 15412 return ( 15413 !inVPre && 15414 !vnode.ns && 15415 !( 15416 config.ignoredElements.length && 15417 config.ignoredElements.some(function (ignore) { 15418 return isRegExp(ignore) 15419 ? ignore.test(vnode.tag) 15420 : ignore === vnode.tag 15421 }) 15422 ) && 15423 config.isUnknownElement(vnode.tag) 15424 ) 15425 } 15426 15427 var creatingElmInVPre = 0; 15428 function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) { 15429 vnode.isRootInsert = !nested; // for transition enter check 15430 if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { 15431 return 15432 } 15433 15434 var data = vnode.data; 15435 var children = vnode.children; 15436 var tag = vnode.tag; 15437 if (isDef(tag)) { 15438 if (process.env.NODE_ENV !== 'production') { 15439 if (data && data.pre) { 15440 creatingElmInVPre++; 15441 } 15442 if (isUnknownElement$$1(vnode, creatingElmInVPre)) { 15443 warn( 15444 'Unknown custom element: <' + tag + '> - did you ' + 15445 'register the component correctly? For recursive components, ' + 15446 'make sure to provide the "name" option.', 15447 vnode.context 15448 ); 15449 } 15450 } 15451 vnode.elm = vnode.ns 15452 ? nodeOps.createElementNS(vnode.ns, tag) 15453 : nodeOps.createElement(tag, vnode); 15454 setScope(vnode); 15455 15456 /* istanbul ignore if */ 15457 { 15458 createChildren(vnode, children, insertedVnodeQueue); 15459 if (isDef(data)) { 15460 invokeCreateHooks(vnode, insertedVnodeQueue); 15461 } 15462 insert(parentElm, vnode.elm, refElm); 15463 } 15464 15465 if (process.env.NODE_ENV !== 'production' && data && data.pre) { 15466 creatingElmInVPre--; 15467 } 15468 } else if (isTrue(vnode.isComment)) { 15469 vnode.elm = nodeOps.createComment(vnode.text); 15470 insert(parentElm, vnode.elm, refElm); 15471 } else { 15472 vnode.elm = nodeOps.createTextNode(vnode.text); 15473 insert(parentElm, vnode.elm, refElm); 15474 } 15475 } 15476 15477 function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 15478 var i = vnode.data; 15479 if (isDef(i)) { 15480 var isReactivated = isDef(vnode.componentInstance) && i.keepAlive; 15481 if (isDef(i = i.hook) && isDef(i = i.init)) { 15482 i(vnode, false /* hydrating */, parentElm, refElm); 15483 } 15484 // after calling the init hook, if the vnode is a child component 15485 // it should've created a child instance and mounted it. the child 15486 // component also has set the placeholder vnode's elm. 15487 // in that case we can just return the element and be done. 15488 if (isDef(vnode.componentInstance)) { 15489 initComponent(vnode, insertedVnodeQueue); 15490 if (isTrue(isReactivated)) { 15491 reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); 15492 } 15493 return true 15494 } 15495 } 15496 } 15497 15498 function initComponent (vnode, insertedVnodeQueue) { 15499 if (isDef(vnode.data.pendingInsert)) { 15500 insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); 15501 vnode.data.pendingInsert = null; 15502 } 15503 vnode.elm = vnode.componentInstance.$el; 15504 if (isPatchable(vnode)) { 15505 invokeCreateHooks(vnode, insertedVnodeQueue); 15506 setScope(vnode); 15507 } else { 15508 // empty component root. 15509 // skip all element-related modules except for ref (#3455) 15510 registerRef(vnode); 15511 // make sure to invoke the insert hook 15512 insertedVnodeQueue.push(vnode); 15513 } 15514 } 15515 15516 function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 15517 var i; 15518 // hack for #4339: a reactivated component with inner transition 15519 // does not trigger because the inner node's created hooks are not called 15520 // again. It's not ideal to involve module-specific logic in here but 15521 // there doesn't seem to be a better way to do it. 15522 var innerNode = vnode; 15523 while (innerNode.componentInstance) { 15524 innerNode = innerNode.componentInstance._vnode; 15525 if (isDef(i = innerNode.data) && isDef(i = i.transition)) { 15526 for (i = 0; i < cbs.activate.length; ++i) { 15527 cbs.activate[i](emptyNode, innerNode); 15528 } 15529 insertedVnodeQueue.push(innerNode); 15530 break 15531 } 15532 } 15533 // unlike a newly created component, 15534 // a reactivated keep-alive component doesn't insert itself 15535 insert(parentElm, vnode.elm, refElm); 15536 } 15537 15538 function insert (parent, elm, ref$$1) { 15539 if (isDef(parent)) { 15540 if (isDef(ref$$1)) { 15541 if (ref$$1.parentNode === parent) { 15542 nodeOps.insertBefore(parent, elm, ref$$1); 15543 } 15544 } else { 15545 nodeOps.appendChild(parent, elm); 15546 } 15547 } 15548 } 15549 15550 function createChildren (vnode, children, insertedVnodeQueue) { 15551 if (Array.isArray(children)) { 15552 for (var i = 0; i < children.length; ++i) { 15553 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true); 15554 } 15555 } else if (isPrimitive(vnode.text)) { 15556 nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text)); 15557 } 15558 } 15559 15560 function isPatchable (vnode) { 15561 while (vnode.componentInstance) { 15562 vnode = vnode.componentInstance._vnode; 15563 } 15564 return isDef(vnode.tag) 15565 } 15566 15567 function invokeCreateHooks (vnode, insertedVnodeQueue) { 15568 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 15569 cbs.create[i$1](emptyNode, vnode); 15570 } 15571 i = vnode.data.hook; // Reuse variable 15572 if (isDef(i)) { 15573 if (isDef(i.create)) { i.create(emptyNode, vnode); } 15574 if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); } 15575 } 15576 } 15577 15578 // set scope id attribute for scoped CSS. 15579 // this is implemented as a special case to avoid the overhead 15580 // of going through the normal attribute patching process. 15581 function setScope (vnode) { 15582 var i; 15583 if (isDef(i = vnode.functionalScopeId)) { 15584 nodeOps.setAttribute(vnode.elm, i, ''); 15585 } else { 15586 var ancestor = vnode; 15587 while (ancestor) { 15588 if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) { 15589 nodeOps.setAttribute(vnode.elm, i, ''); 15590 } 15591 ancestor = ancestor.parent; 15592 } 15593 } 15594 // for slot content they should also get the scopeId from the host instance. 15595 if (isDef(i = activeInstance) && 15596 i !== vnode.context && 15597 i !== vnode.functionalContext && 15598 isDef(i = i.$options._scopeId) 15599 ) { 15600 nodeOps.setAttribute(vnode.elm, i, ''); 15601 } 15602 } 15603 15604 function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { 15605 for (; startIdx <= endIdx; ++startIdx) { 15606 createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm); 15607 } 15608 } 15609 15610 function invokeDestroyHook (vnode) { 15611 var i, j; 15612 var data = vnode.data; 15613 if (isDef(data)) { 15614 if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); } 15615 for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); } 15616 } 15617 if (isDef(i = vnode.children)) { 15618 for (j = 0; j < vnode.children.length; ++j) { 15619 invokeDestroyHook(vnode.children[j]); 15620 } 15621 } 15622 } 15623 15624 function removeVnodes (parentElm, vnodes, startIdx, endIdx) { 15625 for (; startIdx <= endIdx; ++startIdx) { 15626 var ch = vnodes[startIdx]; 15627 if (isDef(ch)) { 15628 if (isDef(ch.tag)) { 15629 removeAndInvokeRemoveHook(ch); 15630 invokeDestroyHook(ch); 15631 } else { // Text node 15632 removeNode(ch.elm); 15633 } 15634 } 15635 } 15636 } 15637 15638 function removeAndInvokeRemoveHook (vnode, rm) { 15639 if (isDef(rm) || isDef(vnode.data)) { 15640 var i; 15641 var listeners = cbs.remove.length + 1; 15642 if (isDef(rm)) { 15643 // we have a recursively passed down rm callback 15644 // increase the listeners count 15645 rm.listeners += listeners; 15646 } else { 15647 // directly removing 15648 rm = createRmCb(vnode.elm, listeners); 15649 } 15650 // recursively invoke hooks on child component root node 15651 if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) { 15652 removeAndInvokeRemoveHook(i, rm); 15653 } 15654 for (i = 0; i < cbs.remove.length; ++i) { 15655 cbs.remove[i](vnode, rm); 15656 } 15657 if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) { 15658 i(vnode, rm); 15659 } else { 15660 rm(); 15661 } 15662 } else { 15663 removeNode(vnode.elm); 15664 } 15665 } 15666 15667 function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { 15668 var oldStartIdx = 0; 15669 var newStartIdx = 0; 15670 var oldEndIdx = oldCh.length - 1; 15671 var oldStartVnode = oldCh[0]; 15672 var oldEndVnode = oldCh[oldEndIdx]; 15673 var newEndIdx = newCh.length - 1; 15674 var newStartVnode = newCh[0]; 15675 var newEndVnode = newCh[newEndIdx]; 15676 var oldKeyToIdx, idxInOld, vnodeToMove, refElm; 15677 15678 // removeOnly is a special flag used only by <transition-group> 15679 // to ensure removed elements stay in correct relative positions 15680 // during leaving transitions 15681 var canMove = !removeOnly; 15682 15683 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { 15684 if (isUndef(oldStartVnode)) { 15685 oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left 15686 } else if (isUndef(oldEndVnode)) { 15687 oldEndVnode = oldCh[--oldEndIdx]; 15688 } else if (sameVnode(oldStartVnode, newStartVnode)) { 15689 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue); 15690 oldStartVnode = oldCh[++oldStartIdx]; 15691 newStartVnode = newCh[++newStartIdx]; 15692 } else if (sameVnode(oldEndVnode, newEndVnode)) { 15693 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue); 15694 oldEndVnode = oldCh[--oldEndIdx]; 15695 newEndVnode = newCh[--newEndIdx]; 15696 } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right 15697 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); 15698 canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); 15699 oldStartVnode = oldCh[++oldStartIdx]; 15700 newEndVnode = newCh[--newEndIdx]; 15701 } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left 15702 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); 15703 canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); 15704 oldEndVnode = oldCh[--oldEndIdx]; 15705 newStartVnode = newCh[++newStartIdx]; 15706 } else { 15707 if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); } 15708 idxInOld = isDef(newStartVnode.key) 15709 ? oldKeyToIdx[newStartVnode.key] 15710 : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); 15711 if (isUndef(idxInOld)) { // New element 15712 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 15713 } else { 15714 vnodeToMove = oldCh[idxInOld]; 15715 /* istanbul ignore if */ 15716 if (process.env.NODE_ENV !== 'production' && !vnodeToMove) { 15717 warn( 15718 'It seems there are duplicate keys that is causing an update error. ' + 15719 'Make sure each v-for item has a unique key.' 15720 ); 15721 } 15722 if (sameVnode(vnodeToMove, newStartVnode)) { 15723 patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue); 15724 oldCh[idxInOld] = undefined; 15725 canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); 15726 } else { 15727 // same key but different element. treat as new element 15728 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 15729 } 15730 } 15731 newStartVnode = newCh[++newStartIdx]; 15732 } 15733 } 15734 if (oldStartIdx > oldEndIdx) { 15735 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; 15736 addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); 15737 } else if (newStartIdx > newEndIdx) { 15738 removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); 15739 } 15740 } 15741 15742 function findIdxInOld (node, oldCh, start, end) { 15743 for (var i = start; i < end; i++) { 15744 var c = oldCh[i]; 15745 if (isDef(c) && sameVnode(node, c)) { return i } 15746 } 15747 } 15748 15749 function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) { 15750 if (oldVnode === vnode) { 15751 return 15752 } 15753 15754 var elm = vnode.elm = oldVnode.elm; 15755 15756 if (isTrue(oldVnode.isAsyncPlaceholder)) {
vendor: 4,697 bytes, lines 15757-15882
15757 if (isDef(vnode.asyncFactory.resolved)) { 15758 hydrate(oldVnode.elm, vnode, insertedVnodeQueue); 15759 } else { 15760 vnode.isAsyncPlaceholder = true; 15761 } 15762 return 15763 } 15764 15765 // reuse element for static trees. 15766 // note we only do this if the vnode is cloned - 15767 // if the new node is not cloned it means the render functions have been 15768 // reset by the hot-reload-api and we need to do a proper re-render. 15769 if (isTrue(vnode.isStatic) && 15770 isTrue(oldVnode.isStatic) && 15771 vnode.key === oldVnode.key && 15772 (isTrue(vnode.isCloned) || isTrue(vnode.isOnce)) 15773 ) { 15774 vnode.componentInstance = oldVnode.componentInstance; 15775 return 15776 } 15777 15778 var i; 15779 var data = vnode.data; 15780 if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) { 15781 i(oldVnode, vnode); 15782 } 15783 15784 var oldCh = oldVnode.children; 15785 var ch = vnode.children; 15786 if (isDef(data) && isPatchable(vnode)) { 15787 for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); } 15788 if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); } 15789 } 15790 if (isUndef(vnode.text)) { 15791 if (isDef(oldCh) && isDef(ch)) { 15792 if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); } 15793 } else if (isDef(ch)) { 15794 if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); } 15795 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); 15796 } else if (isDef(oldCh)) { 15797 removeVnodes(elm, oldCh, 0, oldCh.length - 1); 15798 } else if (isDef(oldVnode.text)) { 15799 nodeOps.setTextContent(elm, ''); 15800 } 15801 } else if (oldVnode.text !== vnode.text) { 15802 nodeOps.setTextContent(elm, vnode.text); 15803 } 15804 if (isDef(data)) { 15805 if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); } 15806 } 15807 } 15808 15809 function invokeInsertHook (vnode, queue, initial) { 15810 // delay insert hooks for component root nodes, invoke them after the 15811 // element is really inserted 15812 if (isTrue(initial) && isDef(vnode.parent)) { 15813 vnode.parent.data.pendingInsert = queue; 15814 } else { 15815 for (var i = 0; i < queue.length; ++i) { 15816 queue[i].data.hook.insert(queue[i]); 15817 } 15818 } 15819 } 15820 15821 var hydrationBailed = false; 15822 // list of modules that can skip create hook during hydration because they 15823 // are already rendered on the client or has no need for initialization 15824 // Note: style is excluded because it relies on initial clone for future 15825 // deep updates (#7063). 15826 var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key'); 15827 15828 // Note: this is a browser-only function so we can assume elms are DOM nodes. 15829 function hydrate (elm, vnode, insertedVnodeQueue, inVPre) { 15830 var i; 15831 var tag = vnode.tag; 15832 var data = vnode.data; 15833 var children = vnode.children; 15834 inVPre = inVPre || (data && data.pre); 15835 vnode.elm = elm; 15836 15837 if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { 15838 vnode.isAsyncPlaceholder = true; 15839 return true 15840 } 15841 // assert node match 15842 if (process.env.NODE_ENV !== 'production') { 15843 if (!assertNodeMatch(elm, vnode, inVPre)) { 15844 return false 15845 } 15846 } 15847 if (isDef(data)) { 15848 if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); } 15849 if (isDef(i = vnode.componentInstance)) { 15850 // child component. it should have hydrated its own tree. 15851 initComponent(vnode, insertedVnodeQueue); 15852 return true 15853 } 15854 } 15855 if (isDef(tag)) { 15856 if (isDef(children)) { 15857 // empty element, allow client to pick up and populate children 15858 if (!elm.hasChildNodes()) { 15859 createChildren(vnode, children, insertedVnodeQueue); 15860 } else { 15861 // v-html and domProps: innerHTML 15862 if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) { 15863 if (i !== elm.innerHTML) { 15864 /* istanbul ignore if */ 15865 if (process.env.NODE_ENV !== 'production' && 15866 typeof console !== 'undefined' && 15867 !hydrationBailed 15868 ) { 15869 hydrationBailed = true; 15870 console.warn('Parent: ', elm); 15871 console.warn('server innerHTML: ', i); 15872 console.warn('client innerHTML: ', elm.innerHTML); 15873 } 15874 return false 15875 } 15876 } else { 15877 // iterate and compare children lists 15878 var childrenMatch = true; 15879 var childNode = elm.firstChild; 15880 for (var i$1 = 0; i$1 < children.length; i$1++) { 15881 if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) { 15882 childrenMatch = false;
15883 break 15884 } 15885 childNode = childNode.nextSibling; 15886 } 15887 // if childNode is not null, it means the actual childNodes list is 15888 // longer than the virtual children list. 15889 if (!childrenMatch || childNode) { 15890 /* istanbul ignore if */ 15891 if (process.env.NODE_ENV !== 'production' && 15892 typeof console !== 'undefined' && 15893 !hydrationBailed 15894 ) { 15895 hydrationBailed = true; 15896 console.warn('Parent: ', elm); 15897 console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children); 15898 } 15899 return false 15900 } 15901 } 15902 } 15903 } 15904 if (isDef(data)) { 15905 var fullInvoke = false; 15906 for (var key in data) { 15907 if (!isRenderedModule(key)) { 15908 fullInvoke = true; 15909 invokeCreateHooks(vnode, insertedVnodeQueue); 15910 break 15911 } 15912 } 15913 if (!fullInvoke && data['class']) { 15914 // ensure collecting deps for deep class bindings for future updates 15915 traverse(data['class']); 15916 } 15917 } 15918 } else if (elm.data !== vnode.text) { 15919 elm.data = vnode.text; 15920 } 15921 return true 15922 } 15923 15924 function assertNodeMatch (node, vnode, inVPre) {
vendor: 2,765 bytes, lines 15925-15996
15925 if (isDef(vnode.tag)) { 15926 return vnode.tag.indexOf('vue-component') === 0 || ( 15927 !isUnknownElement$$1(vnode, inVPre) && 15928 vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()) 15929 ) 15930 } else { 15931 return node.nodeType === (vnode.isComment ? 8 : 3) 15932 } 15933 } 15934 15935 return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) { 15936 if (isUndef(vnode)) { 15937 if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); } 15938 return 15939 } 15940 15941 var isInitialPatch = false; 15942 var insertedVnodeQueue = []; 15943 15944 if (isUndef(oldVnode)) { 15945 // empty mount (likely as component), create new root element 15946 isInitialPatch = true; 15947 createElm(vnode, insertedVnodeQueue, parentElm, refElm); 15948 } else { 15949 var isRealElement = isDef(oldVnode.nodeType); 15950 if (!isRealElement && sameVnode(oldVnode, vnode)) { 15951 // patch existing root node 15952 patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly); 15953 } else { 15954 if (isRealElement) { 15955 // mounting to a real element 15956 // check if this is server-rendered content and if we can perform 15957 // a successful hydration. 15958 if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { 15959 oldVnode.removeAttribute(SSR_ATTR); 15960 hydrating = true; 15961 } 15962 if (isTrue(hydrating)) { 15963 if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { 15964 invokeInsertHook(vnode, insertedVnodeQueue, true); 15965 return oldVnode 15966 } else if (process.env.NODE_ENV !== 'production') { 15967 warn( 15968 'The client-side rendered virtual DOM tree is not matching ' + 15969 'server-rendered content. This is likely caused by incorrect ' + 15970 'HTML markup, for example nesting block-level elements inside ' + 15971 '<p>, or missing <tbody>. Bailing hydration and performing ' + 15972 'full client-side render.' 15973 ); 15974 } 15975 } 15976 // either not server-rendered, or hydration failed. 15977 // create an empty node and replace it 15978 oldVnode = emptyNodeAt(oldVnode); 15979 } 15980 15981 // replacing existing element 15982 var oldElm = oldVnode.elm; 15983 var parentElm$1 = nodeOps.parentNode(oldElm); 15984 15985 // create new node 15986 createElm( 15987 vnode, 15988 insertedVnodeQueue, 15989 // extremely rare edge case: do not insert if old element is in a 15990 // leaving transition. Only happens when combining transition + 15991 // keep-alive + HOCs. (#4590) 15992 oldElm._leaveCb ? null : parentElm$1, 15993 nodeOps.nextSibling(oldElm) 15994 ); 15995 15996 // update parent placeholder node element, recursively
vendor: 5,863 bytes, lines 15997-16211
15997 if (isDef(vnode.parent)) { 15998 var ancestor = vnode.parent; 15999 var patchable = isPatchable(vnode); 16000 while (ancestor) { 16001 for (var i = 0; i < cbs.destroy.length; ++i) { 16002 cbs.destroy[i](ancestor); 16003 } 16004 ancestor.elm = vnode.elm; 16005 if (patchable) { 16006 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 16007 cbs.create[i$1](emptyNode, ancestor); 16008 } 16009 // #6513 16010 // invoke insert hooks that may have been merged by create hooks. 16011 // e.g. for directives that uses the "inserted" hook. 16012 var insert = ancestor.data.hook.insert; 16013 if (insert.merged) { 16014 // start at index 1 to avoid re-invoking component mounted hook 16015 for (var i$2 = 1; i$2 < insert.fns.length; i$2++) { 16016 insert.fns[i$2](); 16017 } 16018 } 16019 } else { 16020 registerRef(ancestor); 16021 } 16022 ancestor = ancestor.parent; 16023 } 16024 } 16025 16026 // destroy old node 16027 if (isDef(parentElm$1)) { 16028 removeVnodes(parentElm$1, [oldVnode], 0, 0); 16029 } else if (isDef(oldVnode.tag)) { 16030 invokeDestroyHook(oldVnode); 16031 } 16032 } 16033 } 16034 16035 invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); 16036 return vnode.elm 16037 } 16038} 16039 16040/* */ 16041 16042var directives = { 16043 create: updateDirectives, 16044 update: updateDirectives, 16045 destroy: function unbindDirectives (vnode) { 16046 updateDirectives(vnode, emptyNode); 16047 } 16048}; 16049 16050function updateDirectives (oldVnode, vnode) { 16051 if (oldVnode.data.directives || vnode.data.directives) { 16052 _update(oldVnode, vnode); 16053 } 16054} 16055 16056function _update (oldVnode, vnode) { 16057 var isCreate = oldVnode === emptyNode; 16058 var isDestroy = vnode === emptyNode; 16059 var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); 16060 var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); 16061 16062 var dirsWithInsert = []; 16063 var dirsWithPostpatch = []; 16064 16065 var key, oldDir, dir; 16066 for (key in newDirs) { 16067 oldDir = oldDirs[key]; 16068 dir = newDirs[key]; 16069 if (!oldDir) { 16070 // new directive, bind 16071 callHook$1(dir, 'bind', vnode, oldVnode); 16072 if (dir.def && dir.def.inserted) { 16073 dirsWithInsert.push(dir); 16074 } 16075 } else { 16076 // existing directive, update 16077 dir.oldValue = oldDir.value; 16078 callHook$1(dir, 'update', vnode, oldVnode); 16079 if (dir.def && dir.def.componentUpdated) { 16080 dirsWithPostpatch.push(dir); 16081 } 16082 } 16083 } 16084 16085 if (dirsWithInsert.length) { 16086 var callInsert = function () { 16087 for (var i = 0; i < dirsWithInsert.length; i++) { 16088 callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); 16089 } 16090 }; 16091 if (isCreate) { 16092 mergeVNodeHook(vnode, 'insert', callInsert); 16093 } else { 16094 callInsert(); 16095 } 16096 } 16097 16098 if (dirsWithPostpatch.length) { 16099 mergeVNodeHook(vnode, 'postpatch', function () { 16100 for (var i = 0; i < dirsWithPostpatch.length; i++) { 16101 callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); 16102 } 16103 }); 16104 } 16105 16106 if (!isCreate) { 16107 for (key in oldDirs) { 16108 if (!newDirs[key]) { 16109 // no longer present, unbind 16110 callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); 16111 } 16112 } 16113 } 16114} 16115 16116var emptyModifiers = Object.create(null); 16117 16118function normalizeDirectives$1 ( 16119 dirs, 16120 vm 16121) { 16122 var res = Object.create(null); 16123 if (!dirs) { 16124 return res 16125 } 16126 var i, dir; 16127 for (i = 0; i < dirs.length; i++) { 16128 dir = dirs[i]; 16129 if (!dir.modifiers) { 16130 dir.modifiers = emptyModifiers; 16131 } 16132 res[getRawDirName(dir)] = dir; 16133 dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); 16134 } 16135 return res 16136} 16137 16138function getRawDirName (dir) { 16139 return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) 16140} 16141 16142function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { 16143 var fn = dir.def && dir.def[hook]; 16144 if (fn) { 16145 try { 16146 fn(vnode.elm, dir, vnode, oldVnode, isDestroy); 16147 } catch (e) { 16148 handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook")); 16149 } 16150 } 16151} 16152 16153var baseModules = [ 16154 ref, 16155 directives 16156]; 16157 16158/* */ 16159 16160function updateAttrs (oldVnode, vnode) { 16161 var opts = vnode.componentOptions; 16162 if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { 16163 return 16164 } 16165 if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { 16166 return 16167 } 16168 var key, cur, old; 16169 var elm = vnode.elm; 16170 var oldAttrs = oldVnode.data.attrs || {}; 16171 var attrs = vnode.data.attrs || {}; 16172 // clone observed objects, as the user probably wants to mutate it 16173 if (isDef(attrs.__ob__)) { 16174 attrs = vnode.data.attrs = extend({}, attrs); 16175 } 16176 16177 for (key in attrs) { 16178 cur = attrs[key]; 16179 old = oldAttrs[key]; 16180 if (old !== cur) { 16181 setAttr(elm, key, cur); 16182 } 16183 } 16184 // #4391: in IE9, setting type can reset value for input[type=radio] 16185 // #6666: IE/Edge forces progress value down to 1 before setting a max 16186 /* istanbul ignore if */ 16187 if ((isIE9 || isEdge) && attrs.value !== oldAttrs.value) { 16188 setAttr(elm, 'value', attrs.value); 16189 } 16190 for (key in oldAttrs) { 16191 if (isUndef(attrs[key])) { 16192 if (isXlink(key)) { 16193 elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); 16194 } else if (!isEnumeratedAttr(key)) { 16195 elm.removeAttribute(key); 16196 } 16197 } 16198 } 16199} 16200 16201function setAttr (el, key, value) { 16202 if (isBooleanAttr(key)) { 16203 // set attribute for blank value 16204 // e.g. <option disabled>Select one</option> 16205 if (isFalsyAttrValue(value)) { 16206 el.removeAttribute(key); 16207 } else { 16208 // technically allowfullscreen is a boolean attribute for <iframe>, 16209 // but Flash expects a value of "true" when used on <embed> tag 16210 value = key === 'allowfullscreen' && el.tagName === 'EMBED' 16211 ? 'true'
16212 : key; 16213 el.setAttribute(key, value); 16214 } 16215 } else if (isEnumeratedAttr(key)) { 16216 el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); 16217 } else if (isXlink(key)) { 16218 if (isFalsyAttrValue(value)) { 16219 el.removeAttributeNS(xlinkNS, getXlinkProp(key)); 16220 } else { 16221 el.setAttributeNS(xlinkNS, key, value); 16222 } 16223 } else { 16224 if (isFalsyAttrValue(value)) { 16225 el.removeAttribute(key); 16226 } else { 16227 el.setAttribute(key, value); 16228 } 16229 } 16230} 16231 16232var attrs = { 16233 create: updateAttrs, 16234 update: updateAttrs 16235}; 16236 16237/* */ 16238 16239function updateClass (oldVnode, vnode) { 16240 var el = vnode.elm; 16241 var data = vnode.data; 16242 var oldData = oldVnode.data; 16243 if ( 16244 isUndef(data.staticClass) && 16245 isUndef(data.class) && ( 16246 isUndef(oldData) || ( 16247 isUndef(oldData.staticClass) && 16248 isUndef(oldData.class) 16249 ) 16250 ) 16251 ) { 16252 return 16253 } 16254 16255 var cls = genClassForVnode(vnode); 16256 16257 // handle transition classes 16258 var transitionClass = el._transitionClasses; 16259 if (isDef(transitionClass)) { 16260 cls = concat(cls, stringifyClass(transitionClass)); 16261 } 16262 16263 // set the class 16264 if (cls !== el._prevClass) { 16265 el.setAttribute('class', cls); 16266 el._prevClass = cls; 16267 } 16268} 16269 16270var klass = { 16271 create: updateClass, 16272 update: updateClass 16273}; 16274 16275/* */ 16276 16277var validDivisionCharRE = /[\w).+\-_$\]]/; 16278 16279function parseFilters (exp) { 16280 var inSingle = false; 16281 var inDouble = false; 16282 var inTemplateString = false; 16283 var inRegex = false; 16284 var curly = 0; 16285 var square = 0; 16286 var paren = 0; 16287 var lastFilterIndex = 0; 16288 var c, prev, i, expression, filters; 16289 16290 for (i = 0; i < exp.length; i++) { 16291 prev = c; 16292 c = exp.charCodeAt(i); 16293 if (inSingle) { 16294 if (c === 0x27 && prev !== 0x5C) { inSingle = false; } 16295 } else if (inDouble) { 16296 if (c === 0x22 && prev !== 0x5C) { inDouble = false; } 16297 } else if (inTemplateString) { 16298 if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; } 16299 } else if (inRegex) { 16300 if (c === 0x2f && prev !== 0x5C) { inRegex = false; } 16301 } else if ( 16302 c === 0x7C && // pipe 16303 exp.charCodeAt(i + 1) !== 0x7C && 16304 exp.charCodeAt(i - 1) !== 0x7C && 16305 !curly && !square && !paren 16306 ) { 16307 if (expression === undefined) { 16308 // first filter, end of expression 16309 lastFilterIndex = i + 1; 16310 expression = exp.slice(0, i).trim(); 16311 } else { 16312 pushFilter(); 16313 } 16314 } else { 16315 switch (c) { 16316 case 0x22: inDouble = true; break // " 16317 case 0x27: inSingle = true; break // ' 16318 case 0x60: inTemplateString = true; break // ` 16319 case 0x28: paren++; break // ( 16320 case 0x29: paren--; break // ) 16321 case 0x5B: square++; break // [ 16322 case 0x5D: square--; break // ] 16323 case 0x7B: curly++; break // { 16324 case 0x7D: curly--; break // } 16325 } 16326 if (c === 0x2f) { // / 16327 var j = i - 1; 16328 var p = (void 0); 16329 // find first non-whitespace prev char 16330 for (; j >= 0; j--) { 16331 p = exp.charAt(j); 16332 if (p !== ' ') { break } 16333 } 16334 if (!p || !validDivisionCharRE.test(p)) { 16335 inRegex = true; 16336 } 16337 } 16338 } 16339 } 16340 16341 if (expression === undefined) { 16342 expression = exp.slice(0, i).trim(); 16343 } else if (lastFilterIndex !== 0) { 16344 pushFilter(); 16345 } 16346 16347 function pushFilter () { 16348 (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); 16349 lastFilterIndex = i + 1; 16350 } 16351 16352 if (filters) { 16353 for (i = 0; i < filters.length; i++) { 16354 expression = wrapFilter(expression, filters[i]); 16355 } 16356 } 16357 16358 return expression 16359} 16360 16361function wrapFilter (exp, filter) { 16362 var i = filter.indexOf('('); 16363 if (i < 0) { 16364 // _f: resolveFilter 16365 return ("_f(\"" + filter + "\")(" + exp + ")") 16366 } else { 16367 var name = filter.slice(0, i); 16368 var args = filter.slice(i + 1); 16369 return ("_f(\"" + name + "\")(" + exp + "," + args) 16370 } 16371} 16372 16373/* */ 16374 16375function baseWarn (msg) { 16376 console.error(("[Vue compiler]: " + msg)); 16377} 16378 16379function pluckModuleFunction ( 16380 modules, 16381 key 16382) { 16383 return modules 16384 ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) 16385 : [] 16386} 16387 16388function addProp (el, name, value) { 16389 (el.props || (el.props = [])).push({ name: name, value: value }); 16390} 16391 16392function addAttr (el, name, value) { 16393 (el.attrs || (el.attrs = [])).push({ name: name, value: value }); 16394} 16395 16396function addDirective ( 16397 el, 16398 name, 16399 rawName, 16400 value, 16401 arg, 16402 modifiers 16403) { 16404 (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers }); 16405} 16406 16407function addHandler ( 16408 el, 16409 name, 16410 value, 16411 modifiers, 16412 important, 16413 warn 16414) { 16415 modifiers = modifiers || emptyObject; 16416 // warn prevent and passive modifier 16417 /* istanbul ignore if */ 16418 if ( 16419 process.env.NODE_ENV !== 'production' && warn && 16420 modifiers.prevent && modifiers.passive 16421 ) { 16422 warn( 16423 'passive and prevent can\'t be used together. ' + 16424 'Passive handler can\'t prevent default event.' 16425 ); 16426 } 16427 16428 // check capture modifier 16429 if (modifiers.capture) { 16430 delete modifiers.capture; 16431 name = '!' + name; // mark the event as captured 16432 } 16433 if (modifiers.once) { 16434 delete modifiers.once; 16435 name = '~' + name; // mark the event as once 16436 } 16437 /* istanbul ignore if */ 16438 if (modifiers.passive) { 16439 delete modifiers.passive; 16440 name = '&' + name; // mark the event as passive 16441 } 16442 16443 // normalize click.right and click.middle since they don't actually fire 16444 // this is technically browser-specific, but at least for now browsers are 16445 // the only target envs that have right/middle clicks.
16446 if (name === 'click') { 16447 if (modifiers.right) { 16448 name = 'contextmenu'; 16449 delete modifiers.right; 16450 } else if (modifiers.middle) { 16451 name = 'mouseup'; 16452 } 16453 } 16454 16455 var events; 16456 if (modifiers.native) { 16457 delete modifiers.native; 16458 events = el.nativeEvents || (el.nativeEvents = {}); 16459 } else { 16460 events = el.events || (el.events = {}); 16461 } 16462 16463 var newHandler = { value: value }; 16464 if (modifiers !== emptyObject) { 16465 newHandler.modifiers = modifiers; 16466 } 16467 16468 var handlers = events[name]; 16469 /* istanbul ignore if */ 16470 if (Array.isArray(handlers)) { 16471 important ? handlers.unshift(newHandler) : handlers.push(newHandler); 16472 } else if (handlers) { 16473 events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; 16474 } else { 16475 events[name] = newHandler; 16476 } 16477} 16478 16479function getBindingAttr ( 16480 el, 16481 name, 16482 getStatic 16483) { 16484 var dynamicValue = 16485 getAndRemoveAttr(el, ':' + name) || 16486 getAndRemoveAttr(el, 'v-bind:' + name); 16487 if (dynamicValue != null) { 16488 return parseFilters(dynamicValue) 16489 } else if (getStatic !== false) { 16490 var staticValue = getAndRemoveAttr(el, name); 16491 if (staticValue != null) { 16492 return JSON.stringify(staticValue) 16493 } 16494 } 16495} 16496 16497// note: this only removes the attr from the Array (attrsList) so that it 16498// doesn't get processed by processAttrs. 16499// By default it does NOT remove it from the map (attrsMap) because the map is 16500// needed during codegen. 16501function getAndRemoveAttr ( 16502 el, 16503 name, 16504 removeFromMap 16505) { 16506 var val; 16507 if ((val = el.attrsMap[name]) != null) { 16508 var list = el.attrsList; 16509 for (var i = 0, l = list.length; i < l; i++) { 16510 if (list[i].name === name) { 16511 list.splice(i, 1); 16512 break 16513 } 16514 } 16515 } 16516 if (removeFromMap) { 16517 delete el.attrsMap[name]; 16518 } 16519 return val 16520} 16521 16522/* */ 16523 16524/** 16525 * Cross-platform code generation for component v-model 16526 */ 16527function genComponentModel ( 16528 el, 16529 value, 16530 modifiers 16531) { 16532 var ref = modifiers || {}; 16533 var number = ref.number; 16534 var trim = ref.trim; 16535 16536 var baseValueExpression = '$$v'; 16537 var valueExpression = baseValueExpression; 16538 if (trim) { 16539 valueExpression = 16540 "(typeof " + baseValueExpression + " === 'string'" + 16541 "? " + baseValueExpression + ".trim()" + 16542 ": " + baseValueExpression + ")"; 16543 } 16544 if (number) { 16545 valueExpression = "_n(" + valueExpression + ")"; 16546 } 16547 var assignment = genAssignmentCode(value, valueExpression); 16548 16549 el.model = { 16550 value: ("(" + value + ")"), 16551 expression: ("\"" + value + "\""), 16552 callback: ("function (" + baseValueExpression + ") {" + assignment + "}") 16553 }; 16554} 16555 16556/** 16557 * Cross-platform codegen helper for generating v-model value assignment code. 16558 */ 16559function genAssignmentCode ( 16560 value, 16561 assignment 16562) { 16563 var res = parseModel(value); 16564 if (res.key === null) { 16565 return (value + "=" + assignment) 16566 } else { 16567 return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")") 16568 } 16569} 16570 16571/** 16572 * Parse a v-model expression into a base path and a final key segment. 16573 * Handles both dot-path and possible square brackets. 16574 * 16575 * Possible cases: 16576 * 16577 * - test 16578 * - test[key] 16579 * - test[test1[key]] 16580 * - test["a"][key] 16581 * - xxx.test[a[a].test1[key]] 16582 * - test.xxx.a["asa"][test1[key]] 16583 * 16584 */ 16585 16586var len; 16587var str; 16588var chr; 16589var index$1; 16590var expressionPos; 16591var expressionEndPos; 16592 16593 16594 16595function parseModel (val) { 16596 len = val.length; 16597 16598 if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { 16599 index$1 = val.lastIndexOf('.'); 16600 if (index$1 > -1) { 16601 return { 16602 exp: val.slice(0, index$1), 16603 key: '"' + val.slice(index$1 + 1) + '"' 16604 } 16605 } else { 16606 return { 16607 exp: val, 16608 key: null 16609 } 16610 } 16611 } 16612 16613 str = val; 16614 index$1 = expressionPos = expressionEndPos = 0; 16615 16616 while (!eof()) { 16617 chr = next(); 16618 /* istanbul ignore if */ 16619 if (isStringStart(chr)) { 16620 parseString(chr); 16621 } else if (chr === 0x5B) { 16622 parseBracket(chr); 16623 } 16624 } 16625 16626 return { 16627 exp: val.slice(0, expressionPos), 16628 key: val.slice(expressionPos + 1, expressionEndPos) 16629 } 16630} 16631 16632function next () { 16633 return str.charCodeAt(++index$1) 16634} 16635 16636function eof () { 16637 return index$1 >= len 16638} 16639 16640function isStringStart (chr) { 16641 return chr === 0x22 || chr === 0x27 16642} 16643 16644function parseBracket (chr) { 16645 var inBracket = 1; 16646 expressionPos = index$1; 16647 while (!eof()) { 16648 chr = next(); 16649 if (isStringStart(chr)) { 16650 parseString(chr); 16651 continue 16652 } 16653 if (chr === 0x5B) { inBracket++; } 16654 if (chr === 0x5D) { inBracket--; } 16655 if (inBracket === 0) { 16656 expressionEndPos = index$1; 16657 break 16658 } 16659 } 16660} 16661 16662function parseString (chr) { 16663 var stringQuote = chr; 16664 while (!eof()) { 16665 chr = next(); 16666 if (chr === stringQuote) { 16667 break 16668 } 16669 } 16670} 16671 16672/* */ 16673 16674var warn$1; 16675 16676// in some cases, the event used has to be determined at runtime 16677// so we used some reserved tokens during compile. 16678var RANGE_TOKEN = '__r'; 16679var CHECKBOX_RADIO_TOKEN = '__c'; 16680 16681function model ( 16682 el, 16683 dir, 16684 _warn 16685) { 16686 warn$1 = _warn; 16687 var value = dir.value; 16688 var modifiers = dir.modifiers; 16689 var tag = el.tag; 16690 var type = el.attrsMap.type; 16691 16692 if (process.env.NODE_ENV !== 'production') { 16693 // inputs with type="file" are read only and setting the input's 16694 // value will throw an error. 16695 if (tag === 'input' && type === 'file') { 16696 warn$1( 16697 "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" + 16698 "File inputs are read only. Use a v-on:change listener instead." 16699 ); 16700 } 16701 } 16702 16703 if (el.component) { 16704 genComponentModel(el, value, modifiers); 16705 // component v-model doesn't need extra runtime 16706 return false 16707 } else if (tag === 'select') { 16708 genSelect(el, value, modifiers); 16709 } else if (tag === 'input' && type === 'checkbox') {
16710 genCheckboxModel(el, value, modifiers); 16711 } else if (tag === 'input' && type === 'radio') { 16712 genRadioModel(el, value, modifiers); 16713 } else if (tag === 'input' || tag === 'textarea') { 16714 genDefaultModel(el, value, modifiers); 16715 } else if (!config.isReservedTag(tag)) { 16716 genComponentModel(el, value, modifiers); 16717 // component v-model doesn't need extra runtime 16718 return false 16719 } else if (process.env.NODE_ENV !== 'production') { 16720 warn$1( 16721 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 16722 "v-model is not supported on this element type. " + 16723 'If you are working with contenteditable, it\'s recommended to ' + 16724 'wrap a library dedicated for that purpose inside a custom component.' 16725 ); 16726 } 16727 16728 // ensure runtime directive metadata 16729 return true 16730} 16731 16732function genCheckboxModel ( 16733 el, 16734 value, 16735 modifiers 16736) { 16737 var number = modifiers && modifiers.number; 16738 var valueBinding = getBindingAttr(el, 'value') || 'null'; 16739 var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; 16740 var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; 16741 addProp(el, 'checked', 16742 "Array.isArray(" + value + ")" + 16743 "?_i(" + value + "," + valueBinding + ")>-1" + ( 16744 trueValueBinding === 'true' 16745 ? (":(" + value + ")") 16746 : (":_q(" + value + "," + trueValueBinding + ")") 16747 ) 16748 ); 16749 addHandler(el, 'change', 16750 "var $$a=" + value + "," + 16751 '$$el=$event.target,' + 16752 "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" + 16753 'if(Array.isArray($$a)){' + 16754 "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," + 16755 '$$i=_i($$a,$$v);' + 16756 "if($$el.checked){$$i<0&&(" + value + "=$$a.concat([$$v]))}" + 16757 "else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" + 16758 "}else{" + (genAssignmentCode(value, '$$c')) + "}", 16759 null, true 16760 ); 16761} 16762 16763function genRadioModel ( 16764 el, 16765 value, 16766 modifiers 16767) { 16768 var number = modifiers && modifiers.number; 16769 var valueBinding = getBindingAttr(el, 'value') || 'null'; 16770 valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding; 16771 addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")")); 16772 addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); 16773} 16774 16775function genSelect ( 16776 el, 16777 value, 16778 modifiers 16779) { 16780 var number = modifiers && modifiers.number; 16781 var selectedVal = "Array.prototype.filter" + 16782 ".call($event.target.options,function(o){return o.selected})" + 16783 ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" + 16784 "return " + (number ? '_n(val)' : 'val') + "})"; 16785 16786 var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; 16787 var code = "var $$selectedVal = " + selectedVal + ";"; 16788 code = code + " " + (genAssignmentCode(value, assignment)); 16789 addHandler(el, 'change', code, null, true); 16790} 16791 16792function genDefaultModel ( 16793 el, 16794 value, 16795 modifiers 16796) { 16797 var type = el.attrsMap.type; 16798 16799 // warn if v-bind:value conflicts with v-model 16800 if (process.env.NODE_ENV !== 'production') { 16801 var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']; 16802 if (value$1) { 16803 var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'; 16804 warn$1( 16805 binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " + 16806 'because the latter already expands to a value binding internally' 16807 ); 16808 } 16809 } 16810 16811 var ref = modifiers || {}; 16812 var lazy = ref.lazy; 16813 var number = ref.number; 16814 var trim = ref.trim; 16815 var needCompositionGuard = !lazy && type !== 'range'; 16816 var event = lazy 16817 ? 'change' 16818 : type === 'range' 16819 ? RANGE_TOKEN 16820 : 'input'; 16821 16822 var valueExpression = '$event.target.value'; 16823 if (trim) { 16824 valueExpression = "$event.target.value.trim()"; 16825 } 16826 if (number) { 16827 valueExpression = "_n(" + valueExpression + ")"; 16828 } 16829 16830 var code = genAssignmentCode(value, valueExpression); 16831 if (needCompositionGuard) { 16832 code = "if($event.target.composing)return;" + code; 16833 } 16834 16835 addProp(el, 'value', ("(" + value + ")")); 16836 addHandler(el, event, code, null, true); 16837 if (trim || number) { 16838 addHandler(el, 'blur', '$forceUpdate()'); 16839 } 16840} 16841 16842/* */ 16843 16844// normalize v-model event tokens that can only be determined at runtime. 16845// it's important to place the event as the first in the array because 16846// the whole point is ensuring the v-model callback gets called before 16847// user-attached handlers. 16848function normalizeEvents (on) { 16849 /* istanbul ignore if */ 16850 if (isDef(on[RANGE_TOKEN])) { 16851 // IE input[type=range] only supports `change` event 16852 var event = isIE ? 'change' : 'input'; 16853 on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); 16854 delete on[RANGE_TOKEN]; 16855 } 16856 // This was originally intended to fix #4521 but no longer necessary 16857 // after 2.5. Keeping it for backwards compat with generated code from < 2.4 16858 /* istanbul ignore if */ 16859 if (isDef(on[CHECKBOX_RADIO_TOKEN])) { 16860 on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []); 16861 delete on[CHECKBOX_RADIO_TOKEN]; 16862 } 16863} 16864 16865var target$1; 16866 16867function createOnceHandler (handler, event, capture) { 16868 var _target = target$1; // save current target element in closure 16869 return function onceHandler () { 16870 var res = handler.apply(null, arguments); 16871 if (res !== null) { 16872 remove$2(event, onceHandler, capture, _target); 16873 } 16874 } 16875} 16876 16877function add$1 ( 16878 event, 16879 handler, 16880 once$$1, 16881 capture, 16882 passive 16883) { 16884 handler = withMacroTask(handler); 16885 if (once$$1) { handler = createOnceHandler(handler, event, capture); } 16886 target$1.addEventListener( 16887 event, 16888 handler, 16889 supportsPassive 16890 ? { capture: capture, passive: passive } 16891 : capture 16892 ); 16893} 16894 16895function remove$2 ( 16896 event, 16897 handler, 16898 capture, 16899 _target 16900) { 16901 (_target || target$1).removeEventListener( 16902 event, 16903 handler._withTask || handler, 16904 capture 16905 ); 16906} 16907 16908function updateDOMListeners (oldVnode, vnode) { 16909 if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { 16910 return 16911 } 16912 var on = vnode.data.on || {}; 16913 var oldOn = oldVnode.data.on || {}; 16914 target$1 = vnode.elm; 16915 normalizeEvents(on); 16916 updateListeners(on, oldOn, add$1, remove$2, vnode.context); 16917 target$1 = undefined; 16918} 16919 16920var events = { 16921 create: updateDOMListeners, 16922 update: updateDOMListeners 16923}; 16924 16925/* */ 16926 16927function updateDOMProps (oldVnode, vnode) { 16928 if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { 16929 return 16930 } 16931 var key, cur; 16932 var elm = vnode.elm; 16933 var oldProps = oldVnode.data.domProps || {}; 16934 var props = vnode.data.domProps || {}; 16935 // clone observed objects, as the user probably wants to mutate it 16936 if (isDef(props.__ob__)) { 16937 props = vnode.data.domProps = extend({}, props); 16938 } 16939 16940 for (key in oldProps) { 16941 if (isUndef(props[key])) { 16942 elm[key] = ''; 16943 } 16944 } 16945 for (key in props) { 16946 cur = props[key]; 16947 // ignore children if the node has textContent or innerHTML, 16948 // as these will throw away existing DOM nodes and cause removal errors 16949 // on subsequent patches (#3360) 16950 if (key === 'textContent' || key === 'innerHTML') { 16951 if (vnode.children) { vnode.children.length = 0; } 16952 if (cur === oldProps[key]) { continue } 16953 // #6601 work around Chrome version <= 55 bug where single textNode 16954 // replaced by innerHTML/textContent retains its parentNode property 16955 if (elm.childNodes.length === 1) { 16956 elm.removeChild(elm.childNodes[0]); 16957 } 16958 } 16959 16960 if (key === 'value') { 16961 // store value as _value as well since 16962 // non-string values will be stringified 16963 elm._value = cur; 16964 // avoid resetting cursor position when value is the same 16965 var strCur = isUndef(cur) ? '' : String(cur); 16966 if (shouldUpdateValue(elm, strCur)) { 16967 elm.value = strCur; 16968 } 16969 } else { 16970 elm[key] = cur; 16971 } 16972 } 16973} 16974 16975// check platforms/web/util/attrs.js acceptValue 16976 16977 16978function shouldUpdateValue (elm, checkVal) { 16979 return (!elm.composing && ( 16980 elm.tagName === 'OPTION' || 16981 isDirty(elm, checkVal) || 16982 isInputChanged(elm, checkVal) 16983 )) 16984} 16985 16986function isDirty (elm, checkVal) { 16987 // return true when textbox (.number and .trim) loses focus and its value is 16988 // not equal to the updated value 16989 var notInFocus = true; 16990 // #6157 16991 // work around IE bug when accessing document.activeElement in an iframe 16992 try { notInFocus = document.activeElement !== elm; } catch (e) {} 16993 return notInFocus && elm.value !== checkVal 16994} 16995 16996function isInputChanged (elm, newVal) { 16997 var value = elm.value; 16998 var modifiers = elm._vModifiers; // injected by v-model runtime 16999 if (isDef(modifiers) && modifiers.number) { 17000 return toNumber(value) !== toNumber(newVal) 17001 } 17002 if (isDef(modifiers) && modifiers.trim) { 17003 return value.trim() !== newVal.trim() 17004 } 17005 return value !== newVal 17006} 17007 17008var domProps = { 17009 create: updateDOMProps, 17010 update: updateDOMProps 17011}; 17012 17013/* */ 17014 17015var parseStyleText = cached(function (cssText) { 17016 var res = {}; 17017 var listDelimiter = /;(?![^(]*\))/g; 17018 var propertyDelimiter = /:(.+)/; 17019 cssText.split(listDelimiter).forEach(function (item) { 17020 if (item) { 17021 var tmp = item.split(propertyDelimiter); 17022 tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); 17023 } 17024 }); 17025 return res 17026}
vendor: 17,103 bytes, lines 17026-17676
17026); 17027 17028// merge static and dynamic style data on the same vnode 17029function normalizeStyleData (data) { 17030 var style = normalizeStyleBinding(data.style); 17031 // static style is pre-processed into an object during compilation 17032 // and is always a fresh object, so it's safe to merge into it 17033 return data.staticStyle 17034 ? extend(data.staticStyle, style) 17035 : style 17036} 17037 17038// normalize possible array / string values into Object 17039function normalizeStyleBinding (bindingStyle) { 17040 if (Array.isArray(bindingStyle)) { 17041 return toObject(bindingStyle) 17042 } 17043 if (typeof bindingStyle === 'string') { 17044 return parseStyleText(bindingStyle) 17045 } 17046 return bindingStyle 17047} 17048 17049/** 17050 * parent component style should be after child's 17051 * so that parent component's style could override it 17052 */ 17053function getStyle (vnode, checkChild) { 17054 var res = {}; 17055 var styleData; 17056 17057 if (checkChild) { 17058 var childNode = vnode; 17059 while (childNode.componentInstance) { 17060 childNode = childNode.componentInstance._vnode; 17061 if (childNode.data && (styleData = normalizeStyleData(childNode.data))) { 17062 extend(res, styleData); 17063 } 17064 } 17065 } 17066 17067 if ((styleData = normalizeStyleData(vnode.data))) { 17068 extend(res, styleData); 17069 } 17070 17071 var parentNode = vnode; 17072 while ((parentNode = parentNode.parent)) { 17073 if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { 17074 extend(res, styleData); 17075 } 17076 } 17077 return res 17078} 17079 17080/* */ 17081 17082var cssVarRE = /^--/; 17083var importantRE = /\s*!important$/; 17084var setProp = function (el, name, val) { 17085 /* istanbul ignore if */ 17086 if (cssVarRE.test(name)) { 17087 el.style.setProperty(name, val); 17088 } else if (importantRE.test(val)) { 17089 el.style.setProperty(name, val.replace(importantRE, ''), 'important'); 17090 } else { 17091 var normalizedName = normalize(name); 17092 if (Array.isArray(val)) { 17093 // Support values array created by autoprefixer, e.g. 17094 // {display: ["-webkit-box", "-ms-flexbox", "flex"]} 17095 // Set them one by one, and the browser will only set those it can recognize 17096 for (var i = 0, len = val.length; i < len; i++) { 17097 el.style[normalizedName] = val[i]; 17098 } 17099 } else { 17100 el.style[normalizedName] = val; 17101 } 17102 } 17103}; 17104 17105var vendorNames = ['Webkit', 'Moz', 'ms']; 17106 17107var emptyStyle; 17108var normalize = cached(function (prop) { 17109 emptyStyle = emptyStyle || document.createElement('div').style; 17110 prop = camelize(prop); 17111 if (prop !== 'filter' && (prop in emptyStyle)) { 17112 return prop 17113 } 17114 var capName = prop.charAt(0).toUpperCase() + prop.slice(1); 17115 for (var i = 0; i < vendorNames.length; i++) { 17116 var name = vendorNames[i] + capName; 17117 if (name in emptyStyle) { 17118 return name 17119 } 17120 } 17121}); 17122 17123function updateStyle (oldVnode, vnode) { 17124 var data = vnode.data; 17125 var oldData = oldVnode.data; 17126 17127 if (isUndef(data.staticStyle) && isUndef(data.style) && 17128 isUndef(oldData.staticStyle) && isUndef(oldData.style) 17129 ) { 17130 return 17131 } 17132 17133 var cur, name; 17134 var el = vnode.elm; 17135 var oldStaticStyle = oldData.staticStyle; 17136 var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; 17137 17138 // if static style exists, stylebinding already merged into it when doing normalizeStyleData 17139 var oldStyle = oldStaticStyle || oldStyleBinding; 17140 17141 var style = normalizeStyleBinding(vnode.data.style) || {}; 17142 17143 // store normalized style under a different key for next diff 17144 // make sure to clone it if it's reactive, since the user likely wants 17145 // to mutate it. 17146 vnode.data.normalizedStyle = isDef(style.__ob__) 17147 ? extend({}, style) 17148 : style; 17149 17150 var newStyle = getStyle(vnode, true); 17151 17152 for (name in oldStyle) { 17153 if (isUndef(newStyle[name])) { 17154 setProp(el, name, ''); 17155 } 17156 } 17157 for (name in newStyle) { 17158 cur = newStyle[name]; 17159 if (cur !== oldStyle[name]) { 17160 // ie9 setting to null has no effect, must use empty string 17161 setProp(el, name, cur == null ? '' : cur); 17162 } 17163 } 17164} 17165 17166var style = { 17167 create: updateStyle, 17168 update: updateStyle 17169}; 17170 17171/* */ 17172 17173/** 17174 * Add class with compatibility for SVG since classList is not supported on 17175 * SVG elements in IE 17176 */ 17177function addClass (el, cls) { 17178 /* istanbul ignore if */ 17179 if (!cls || !(cls = cls.trim())) { 17180 return 17181 } 17182 17183 /* istanbul ignore else */ 17184 if (el.classList) { 17185 if (cls.indexOf(' ') > -1) { 17186 cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); }); 17187 } else { 17188 el.classList.add(cls); 17189 } 17190 } else { 17191 var cur = " " + (el.getAttribute('class') || '') + " "; 17192 if (cur.indexOf(' ' + cls + ' ') < 0) { 17193 el.setAttribute('class', (cur + cls).trim()); 17194 } 17195 } 17196} 17197 17198/** 17199 * Remove class with compatibility for SVG since classList is not supported on 17200 * SVG elements in IE 17201 */ 17202function removeClass (el, cls) { 17203 /* istanbul ignore if */ 17204 if (!cls || !(cls = cls.trim())) { 17205 return 17206 } 17207 17208 /* istanbul ignore else */ 17209 if (el.classList) { 17210 if (cls.indexOf(' ') > -1) { 17211 cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); }); 17212 } else { 17213 el.classList.remove(cls); 17214 } 17215 if (!el.classList.length) { 17216 el.removeAttribute('class'); 17217 } 17218 } else { 17219 var cur = " " + (el.getAttribute('class') || '') + " "; 17220 var tar = ' ' + cls + ' '; 17221 while (cur.indexOf(tar) >= 0) { 17222 cur = cur.replace(tar, ' '); 17223 } 17224 cur = cur.trim(); 17225 if (cur) { 17226 el.setAttribute('class', cur); 17227 } else { 17228 el.removeAttribute('class'); 17229 } 17230 } 17231} 17232 17233/* */ 17234 17235function resolveTransition (def) { 17236 if (!def) { 17237 return 17238 } 17239 /* istanbul ignore else */ 17240 if (typeof def === 'object') { 17241 var res = {}; 17242 if (def.css !== false) { 17243 extend(res, autoCssTransition(def.name || 'v')); 17244 } 17245 extend(res, def); 17246 return res 17247 } else if (typeof def === 'string') { 17248 return autoCssTransition(def) 17249 } 17250} 17251 17252var autoCssTransition = cached(function (name) { 17253 return { 17254 enterClass: (name + "-enter"), 17255 enterToClass: (name + "-enter-to"), 17256 enterActiveClass: (name + "-enter-active"), 17257 leaveClass: (name + "-leave"), 17258 leaveToClass: (name + "-leave-to"), 17259 leaveActiveClass: (name + "-leave-active") 17260 } 17261}); 17262 17263var hasTransition = inBrowser && !isIE9; 17264var TRANSITION = 'transition'; 17265var ANIMATION = 'animation'; 17266 17267// Transition property/event sniffing 17268var transitionProp = 'transition'; 17269var transitionEndEvent = 'transitionend'; 17270var animationProp = 'animation'; 17271var animationEndEvent = 'animationend'; 17272if (hasTransition) { 17273 /* istanbul ignore if */ 17274 if (window.ontransitionend === undefined && 17275 window.onwebkittransitionend !== undefined 17276 ) { 17277 transitionProp = 'WebkitTransition'; 17278 transitionEndEvent = 'webkitTransitionEnd'; 17279 } 17280 if (window.onanimationend === undefined && 17281 window.onwebkitanimationend !== undefined 17282 ) { 17283 animationProp = 'WebkitAnimation'; 17284 animationEndEvent = 'webkitAnimationEnd'; 17285 } 17286} 17287 17288// binding to window is necessary to make hot reload work in IE in strict mode 17289var raf = inBrowser 17290 ? window.requestAnimationFrame 17291 ? window.requestAnimationFrame.bind(window) 17292 : setTimeout 17293 : /* istanbul ignore next */ function (fn) { return fn(); }; 17294 17295function nextFrame (fn) { 17296 raf(function () { 17297 raf(fn); 17298 }); 17299} 17300 17301function addTransitionClass (el, cls) { 17302 var transitionClasses = el._transitionClasses || (el._transitionClasses = []); 17303 if (transitionClasses.indexOf(cls) < 0) { 17304 transitionClasses.push(cls); 17305 addClass(el, cls); 17306 } 17307} 17308 17309function removeTransitionClass (el, cls) { 17310 if (el._transitionClasses) { 17311 remove(el._transitionClasses, cls); 17312 } 17313 removeClass(el, cls); 17314} 17315 17316function whenTransitionEnds ( 17317 el, 17318 expectedType, 17319 cb 17320) { 17321 var ref = getTransitionInfo(el, expectedType); 17322 var type = ref.type; 17323 var timeout = ref.timeout; 17324 var propCount = ref.propCount; 17325 if (!type) { return cb() } 17326 var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; 17327 var ended = 0; 17328 var end = function () { 17329 el.removeEventListener(event, onEnd); 17330 cb(); 17331 }; 17332 var onEnd = function (e) { 17333 if (e.target === el) { 17334 if (++ended >= propCount) { 17335 end(); 17336 } 17337 } 17338 }; 17339 setTimeout(function () { 17340 if (ended < propCount) { 17341 end(); 17342 } 17343 }, timeout + 1); 17344 el.addEventListener(event, onEnd); 17345} 17346 17347var transformRE = /\b(transform|all)(,|$)/; 17348 17349function getTransitionInfo (el, expectedType) { 17350 var styles = window.getComputedStyle(el); 17351 var transitionDelays = styles[transitionProp + 'Delay'].split(', '); 17352 var transitionDurations = styles[transitionProp + 'Duration'].split(', '); 17353 var transitionTimeout = getTimeout(transitionDelays, transitionDurations); 17354 var animationDelays = styles[animationProp + 'Delay'].split(', '); 17355 var animationDurations = styles[animationProp + 'Duration'].split(', '); 17356 var animationTimeout = getTimeout(animationDelays, animationDurations); 17357 17358 var type; 17359 var timeout = 0; 17360 var propCount = 0; 17361 /* istanbul ignore if */ 17362 if (expectedType === TRANSITION) { 17363 if (transitionTimeout > 0) { 17364 type = TRANSITION; 17365 timeout = transitionTimeout; 17366 propCount = transitionDurations.length; 17367 } 17368 } else if (expectedType === ANIMATION) { 17369 if (animationTimeout > 0) { 17370 type = ANIMATION; 17371 timeout = animationTimeout; 17372 propCount = animationDurations.length; 17373 } 17374 } else { 17375 timeout = Math.max(transitionTimeout, animationTimeout); 17376 type = timeout > 0 17377 ? transitionTimeout > animationTimeout 17378 ? TRANSITION 17379 : ANIMATION 17380 : null; 17381 propCount = type 17382 ? type === TRANSITION 17383 ? transitionDurations.length 17384 : animationDurations.length 17385 : 0; 17386 } 17387 var hasTransform = 17388 type === TRANSITION && 17389 transformRE.test(styles[transitionProp + 'Property']); 17390 return { 17391 type: type, 17392 timeout: timeout, 17393 propCount: propCount, 17394 hasTransform: hasTransform 17395 } 17396} 17397 17398function getTimeout (delays, durations) { 17399 /* istanbul ignore next */ 17400 while (delays.length < durations.length) { 17401 delays = delays.concat(delays); 17402 } 17403 17404 return Math.max.apply(null, durations.map(function (d, i) { 17405 return toMs(d) + toMs(delays[i]) 17406 })) 17407} 17408 17409function toMs (s) { 17410 return Number(s.slice(0, -1)) * 1000 17411} 17412 17413/* */ 17414 17415function enter (vnode, toggleDisplay) { 17416 var el = vnode.elm; 17417 17418 // call leave callback now 17419 if (isDef(el._leaveCb)) { 17420 el._leaveCb.cancelled = true; 17421 el._leaveCb(); 17422 } 17423 17424 var data = resolveTransition(vnode.data.transition); 17425 if (isUndef(data)) { 17426 return 17427 } 17428 17429 /* istanbul ignore if */ 17430 if (isDef(el._enterCb) || el.nodeType !== 1) { 17431 return 17432 } 17433 17434 var css = data.css; 17435 var type = data.type; 17436 var enterClass = data.enterClass; 17437 var enterToClass = data.enterToClass; 17438 var enterActiveClass = data.enterActiveClass; 17439 var appearClass = data.appearClass; 17440 var appearToClass = data.appearToClass; 17441 var appearActiveClass = data.appearActiveClass; 17442 var beforeEnter = data.beforeEnter; 17443 var enter = data.enter; 17444 var afterEnter = data.afterEnter; 17445 var enterCancelled = data.enterCancelled; 17446 var beforeAppear = data.beforeAppear; 17447 var appear = data.appear; 17448 var afterAppear = data.afterAppear; 17449 var appearCancelled = data.appearCancelled; 17450 var duration = data.duration; 17451 17452 // activeInstance will always be the <transition> component managing this 17453 // transition. One edge case to check is when the <transition> is placed 17454 // as the root node of a child component. In that case we need to check 17455 // <transition>'s parent for appear check. 17456 var context = activeInstance; 17457 var transitionNode = activeInstance.$vnode; 17458 while (transitionNode && transitionNode.parent) { 17459 transitionNode = transitionNode.parent; 17460 context = transitionNode.context; 17461 } 17462 17463 var isAppear = !context._isMounted || !vnode.isRootInsert; 17464 17465 if (isAppear && !appear && appear !== '') { 17466 return 17467 } 17468 17469 var startClass = isAppear && appearClass 17470 ? appearClass 17471 : enterClass; 17472 var activeClass = isAppear && appearActiveClass 17473 ? appearActiveClass 17474 : enterActiveClass; 17475 var toClass = isAppear && appearToClass 17476 ? appearToClass 17477 : enterToClass; 17478 17479 var beforeEnterHook = isAppear 17480 ? (beforeAppear || beforeEnter) 17481 : beforeEnter; 17482 var enterHook = isAppear 17483 ? (typeof appear === 'function' ? appear : enter) 17484 : enter; 17485 var afterEnterHook = isAppear 17486 ? (afterAppear || afterEnter) 17487 : afterEnter; 17488 var enterCancelledHook = isAppear 17489 ? (appearCancelled || enterCancelled) 17490 : enterCancelled; 17491 17492 var explicitEnterDuration = toNumber( 17493 isObject(duration) 17494 ? duration.enter 17495 : duration 17496 ); 17497 17498 if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) { 17499 checkDuration(explicitEnterDuration, 'enter', vnode); 17500 } 17501 17502 var expectsCSS = css !== false && !isIE9; 17503 var userWantsControl = getHookArgumentsLength(enterHook); 17504 17505 var cb = el._enterCb = once(function () { 17506 if (expectsCSS) { 17507 removeTransitionClass(el, toClass); 17508 removeTransitionClass(el, activeClass); 17509 } 17510 if (cb.cancelled) { 17511 if (expectsCSS) { 17512 removeTransitionClass(el, startClass); 17513 } 17514 enterCancelledHook && enterCancelledHook(el); 17515 } else { 17516 afterEnterHook && afterEnterHook(el); 17517 } 17518 el._enterCb = null; 17519 }); 17520 17521 if (!vnode.data.show) { 17522 // remove pending leave element on enter by injecting an insert hook 17523 mergeVNodeHook(vnode, 'insert', function () { 17524 var parent = el.parentNode; 17525 var pendingNode = parent && parent._pending && parent._pending[vnode.key]; 17526 if (pendingNode && 17527 pendingNode.tag === vnode.tag && 17528 pendingNode.elm._leaveCb 17529 ) { 17530 pendingNode.elm._leaveCb(); 17531 } 17532 enterHook && enterHook(el, cb); 17533 }); 17534 } 17535 17536 // start enter transition 17537 beforeEnterHook && beforeEnterHook(el); 17538 if (expectsCSS) { 17539 addTransitionClass(el, startClass); 17540 addTransitionClass(el, activeClass); 17541 nextFrame(function () { 17542 addTransitionClass(el, toClass); 17543 removeTransitionClass(el, startClass); 17544 if (!cb.cancelled && !userWantsControl) { 17545 if (isValidDuration(explicitEnterDuration)) { 17546 setTimeout(cb, explicitEnterDuration); 17547 } else { 17548 whenTransitionEnds(el, type, cb); 17549 } 17550 } 17551 }); 17552 } 17553 17554 if (vnode.data.show) { 17555 toggleDisplay && toggleDisplay(); 17556 enterHook && enterHook(el, cb); 17557 } 17558 17559 if (!expectsCSS && !userWantsControl) { 17560 cb(); 17561 } 17562} 17563 17564function leave (vnode, rm) { 17565 var el = vnode.elm; 17566 17567 // call enter callback now 17568 if (isDef(el._enterCb)) { 17569 el._enterCb.cancelled = true; 17570 el._enterCb(); 17571 } 17572 17573 var data = resolveTransition(vnode.data.transition); 17574 if (isUndef(data) || el.nodeType !== 1) { 17575 return rm() 17576 } 17577 17578 /* istanbul ignore if */ 17579 if (isDef(el._leaveCb)) { 17580 return 17581 } 17582 17583 var css = data.css; 17584 var type = data.type; 17585 var leaveClass = data.leaveClass; 17586 var leaveToClass = data.leaveToClass; 17587 var leaveActiveClass = data.leaveActiveClass; 17588 var beforeLeave = data.beforeLeave; 17589 var leave = data.leave; 17590 var afterLeave = data.afterLeave; 17591 var leaveCancelled = data.leaveCancelled; 17592 var delayLeave = data.delayLeave; 17593 var duration = data.duration; 17594 17595 var expectsCSS = css !== false && !isIE9; 17596 var userWantsControl = getHookArgumentsLength(leave); 17597 17598 var explicitLeaveDuration = toNumber( 17599 isObject(duration) 17600 ? duration.leave 17601 : duration 17602 ); 17603 17604 if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) { 17605 checkDuration(explicitLeaveDuration, 'leave', vnode); 17606 } 17607 17608 var cb = el._leaveCb = once(function () { 17609 if (el.parentNode && el.parentNode._pending) { 17610 el.parentNode._pending[vnode.key] = null; 17611 } 17612 if (expectsCSS) { 17613 removeTransitionClass(el, leaveToClass); 17614 removeTransitionClass(el, leaveActiveClass); 17615 } 17616 if (cb.cancelled) { 17617 if (expectsCSS) { 17618 removeTransitionClass(el, leaveClass); 17619 } 17620 leaveCancelled && leaveCancelled(el); 17621 } else { 17622 rm(); 17623 afterLeave && afterLeave(el); 17624 } 17625 el._leaveCb = null; 17626 }); 17627 17628 if (delayLeave) { 17629 delayLeave(performLeave); 17630 } else { 17631 performLeave(); 17632 } 17633 17634 function performLeave () { 17635 // the delayed leave may have already been cancelled 17636 if (cb.cancelled) { 17637 return 17638 } 17639 // record leaving element 17640 if (!vnode.data.show) { 17641 (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode; 17642 } 17643 beforeLeave && beforeLeave(el); 17644 if (expectsCSS) { 17645 addTransitionClass(el, leaveClass); 17646 addTransitionClass(el, leaveActiveClass); 17647 nextFrame(function () { 17648 addTransitionClass(el, leaveToClass); 17649 removeTransitionClass(el, leaveClass); 17650 if (!cb.cancelled && !userWantsControl) { 17651 if (isValidDuration(explicitLeaveDuration)) { 17652 setTimeout(cb, explicitLeaveDuration); 17653 } else { 17654 whenTransitionEnds(el, type, cb); 17655 } 17656 } 17657 }); 17658 } 17659 leave && leave(el, cb); 17660 if (!expectsCSS && !userWantsControl) { 17661 cb(); 17662 } 17663 } 17664} 17665 17666// only used in dev mode 17667function checkDuration (val, name, vnode) { 17668 if (typeof val !== 'number') { 17669 warn( 17670 "<transition> explicit " + name + " duration is not a valid number - " + 17671 "got " + (JSON.stringify(val)) + ".", 17672 vnode.context 17673 ); 17674 } else if (isNaN(val)) { 17675 warn( 17676 "<transition>
vendor: 5,579 bytes, lines 17676-17877
17676 explicit " + name + " duration is NaN - " + 17677 'the duration expression might be incorrect.', 17678 vnode.context 17679 ); 17680 } 17681} 17682 17683function isValidDuration (val) { 17684 return typeof val === 'number' && !isNaN(val) 17685} 17686 17687/** 17688 * Normalize a transition hook's argument length. The hook may be: 17689 * - a merged hook (invoker) with the original in .fns 17690 * - a wrapped component method (check ._length) 17691 * - a plain function (.length) 17692 */ 17693function getHookArgumentsLength (fn) { 17694 if (isUndef(fn)) { 17695 return false 17696 } 17697 var invokerFns = fn.fns; 17698 if (isDef(invokerFns)) { 17699 // invoker 17700 return getHookArgumentsLength( 17701 Array.isArray(invokerFns) 17702 ? invokerFns[0] 17703 : invokerFns 17704 ) 17705 } else { 17706 return (fn._length || fn.length) > 1 17707 } 17708} 17709 17710function _enter (_, vnode) { 17711 if (vnode.data.show !== true) { 17712 enter(vnode); 17713 } 17714} 17715 17716var transition = inBrowser ? { 17717 create: _enter, 17718 activate: _enter, 17719 remove: function remove$$1 (vnode, rm) { 17720 /* istanbul ignore else */ 17721 if (vnode.data.show !== true) { 17722 leave(vnode, rm); 17723 } else { 17724 rm(); 17725 } 17726 } 17727} : {}; 17728 17729var platformModules = [ 17730 attrs, 17731 klass, 17732 events, 17733 domProps, 17734 style, 17735 transition 17736]; 17737 17738/* */ 17739 17740// the directive module should be applied last, after all 17741// built-in modules have been applied. 17742var modules = platformModules.concat(baseModules); 17743 17744var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules }); 17745 17746/** 17747 * Not type checking this file because flow doesn't like attaching 17748 * properties to Elements. 17749 */ 17750 17751/* istanbul ignore if */ 17752if (isIE9) { 17753 // http://www.matts411.com/post/internet-explorer-9-oninput/ 17754 document.addEventListener('selectionchange', function () { 17755 var el = document.activeElement; 17756 if (el && el.vmodel) { 17757 trigger(el, 'input'); 17758 } 17759 }); 17760} 17761 17762var directive = { 17763 inserted: function inserted (el, binding, vnode, oldVnode) { 17764 if (vnode.tag === 'select') { 17765 // #6903 17766 if (oldVnode.elm && !oldVnode.elm._vOptions) { 17767 mergeVNodeHook(vnode, 'postpatch', function () { 17768 directive.componentUpdated(el, binding, vnode); 17769 }); 17770 } else { 17771 setSelected(el, binding, vnode.context); 17772 } 17773 el._vOptions = [].map.call(el.options, getValue); 17774 } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) { 17775 el._vModifiers = binding.modifiers; 17776 if (!binding.modifiers.lazy) { 17777 // Safari < 10.2 & UIWebView doesn't fire compositionend when 17778 // switching focus before confirming composition choice 17779 // this also fixes the issue where some browsers e.g. iOS Chrome 17780 // fires "change" instead of "input" on autocomplete. 17781 el.addEventListener('change', onCompositionEnd); 17782 if (!isAndroid) { 17783 el.addEventListener('compositionstart', onCompositionStart); 17784 el.addEventListener('compositionend', onCompositionEnd); 17785 } 17786 /* istanbul ignore if */ 17787 if (isIE9) { 17788 el.vmodel = true; 17789 } 17790 } 17791 } 17792 }, 17793 17794 componentUpdated: function componentUpdated (el, binding, vnode) { 17795 if (vnode.tag === 'select') { 17796 setSelected(el, binding, vnode.context); 17797 // in case the options rendered by v-for have changed, 17798 // it's possible that the value is out-of-sync with the rendered options. 17799 // detect such cases and filter out values that no longer has a matching 17800 // option in the DOM. 17801 var prevOptions = el._vOptions; 17802 var curOptions = el._vOptions = [].map.call(el.options, getValue); 17803 if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) { 17804 // trigger change event if 17805 // no matching option found for at least one value 17806 var needReset = el.multiple 17807 ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); }) 17808 : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions); 17809 if (needReset) { 17810 trigger(el, 'change'); 17811 } 17812 } 17813 } 17814 } 17815}; 17816 17817function setSelected (el, binding, vm) { 17818 actuallySetSelected(el, binding, vm); 17819 /* istanbul ignore if */ 17820 if (isIE || isEdge) { 17821 setTimeout(function () { 17822 actuallySetSelected(el, binding, vm); 17823 }, 0); 17824 } 17825} 17826 17827function actuallySetSelected (el, binding, vm) { 17828 var value = binding.value; 17829 var isMultiple = el.multiple; 17830 if (isMultiple && !Array.isArray(value)) { 17831 process.env.NODE_ENV !== 'production' && warn( 17832 "<select multiple v-model=\"" + (binding.expression) + "\"> " + 17833 "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)), 17834 vm 17835 ); 17836 return 17837 } 17838 var selected, option; 17839 for (var i = 0, l = el.options.length; i < l; i++) { 17840 option = el.options[i]; 17841 if (isMultiple) { 17842 selected = looseIndexOf(value, getValue(option)) > -1; 17843 if (option.selected !== selected) { 17844 option.selected = selected; 17845 } 17846 } else { 17847 if (looseEqual(getValue(option), value)) { 17848 if (el.selectedIndex !== i) { 17849 el.selectedIndex = i; 17850 } 17851 return 17852 } 17853 } 17854 } 17855 if (!isMultiple) { 17856 el.selectedIndex = -1; 17857 } 17858} 17859 17860function hasNoMatchingOption (value, options) { 17861 return options.every(function (o) { return !looseEqual(o, value); }) 17862} 17863 17864function getValue (option) { 17865 return '_value' in option 17866 ? option._value 17867 : option.value 17868} 17869 17870function onCompositionStart (e) { 17871 e.target.composing = true; 17872} 17873 17874function onCompositionEnd (e) { 17875 // prevent triggering an input event for no reason 17876 if (!e.target.composing) { return } 17877 e.target.composing = false;
vendor: 4,322 bytes, lines 17878-18058
17878 trigger(e.target, 'input'); 17879} 17880 17881function trigger (el, type) { 17882 var e = document.createEvent('HTMLEvents'); 17883 e.initEvent(type, true, true); 17884 el.dispatchEvent(e); 17885} 17886 17887/* */ 17888 17889// recursively search for possible transition defined inside the component root 17890function locateNode (vnode) { 17891 return vnode.componentInstance && (!vnode.data || !vnode.data.transition) 17892 ? locateNode(vnode.componentInstance._vnode) 17893 : vnode 17894} 17895 17896var show = { 17897 bind: function bind (el, ref, vnode) { 17898 var value = ref.value; 17899 17900 vnode = locateNode(vnode); 17901 var transition$$1 = vnode.data && vnode.data.transition; 17902 var originalDisplay = el.__vOriginalDisplay = 17903 el.style.display === 'none' ? '' : el.style.display; 17904 if (value && transition$$1) { 17905 vnode.data.show = true; 17906 enter(vnode, function () { 17907 el.style.display = originalDisplay; 17908 }); 17909 } else { 17910 el.style.display = value ? originalDisplay : 'none'; 17911 } 17912 }, 17913 17914 update: function update (el, ref, vnode) { 17915 var value = ref.value; 17916 var oldValue = ref.oldValue; 17917 17918 /* istanbul ignore if */ 17919 if (value === oldValue) { return } 17920 vnode = locateNode(vnode); 17921 var transition$$1 = vnode.data && vnode.data.transition; 17922 if (transition$$1) { 17923 vnode.data.show = true; 17924 if (value) { 17925 enter(vnode, function () { 17926 el.style.display = el.__vOriginalDisplay; 17927 }); 17928 } else { 17929 leave(vnode, function () { 17930 el.style.display = 'none'; 17931 }); 17932 } 17933 } else { 17934 el.style.display = value ? el.__vOriginalDisplay : 'none'; 17935 } 17936 }, 17937 17938 unbind: function unbind ( 17939 el, 17940 binding, 17941 vnode, 17942 oldVnode, 17943 isDestroy 17944 ) { 17945 if (!isDestroy) { 17946 el.style.display = el.__vOriginalDisplay; 17947 } 17948 } 17949}; 17950 17951var platformDirectives = { 17952 model: directive, 17953 show: show 17954}; 17955 17956/* */ 17957 17958// Provides transition support for a single element/component. 17959// supports transition mode (out-in / in-out) 17960 17961var transitionProps = { 17962 name: String, 17963 appear: Boolean, 17964 css: Boolean, 17965 mode: String, 17966 type: String, 17967 enterClass: String, 17968 leaveClass: String, 17969 enterToClass: String, 17970 leaveToClass: String, 17971 enterActiveClass: String, 17972 leaveActiveClass: String, 17973 appearClass: String, 17974 appearActiveClass: String, 17975 appearToClass: String, 17976 duration: [Number, String, Object] 17977}; 17978 17979// in case the child is also an abstract component, e.g. <keep-alive> 17980// we want to recursively retrieve the real component to be rendered 17981function getRealChild (vnode) { 17982 var compOptions = vnode && vnode.componentOptions; 17983 if (compOptions && compOptions.Ctor.options.abstract) { 17984 return getRealChild(getFirstComponentChild(compOptions.children)) 17985 } else { 17986 return vnode 17987 } 17988} 17989 17990function extractTransitionData (comp) { 17991 var data = {}; 17992 var options = comp.$options; 17993 // props 17994 for (var key in options.propsData) { 17995 data[key] = comp[key]; 17996 } 17997 // events. 17998 // extract listeners and pass them directly to the transition methods 17999 var listeners = options._parentListeners; 18000 for (var key$1 in listeners) { 18001 data[camelize(key$1)] = listeners[key$1]; 18002 } 18003 return data 18004} 18005 18006function placeholder (h, rawChild) { 18007 if (/\d-keep-alive$/.test(rawChild.tag)) { 18008 return h('keep-alive', { 18009 props: rawChild.componentOptions.propsData 18010 }) 18011 } 18012} 18013 18014function hasParentTransition (vnode) { 18015 while ((vnode = vnode.parent)) { 18016 if (vnode.data.transition) { 18017 return true 18018 } 18019 } 18020} 18021 18022function isSameChild (child, oldChild) { 18023 return oldChild.key === child.key && oldChild.tag === child.tag 18024} 18025 18026var Transition = { 18027 name: 'transition', 18028 props: transitionProps, 18029 abstract: true, 18030 18031 render: function render (h) { 18032 var this$1 = this; 18033 18034 var children = this.$slots.default; 18035 if (!children) { 18036 return 18037 } 18038 18039 // filter out text nodes (possible whitespaces) 18040 children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c); }); 18041 /* istanbul ignore if */ 18042 if (!children.length) { 18043 return 18044 } 18045 18046 // warn multiple elements 18047 if (process.env.NODE_ENV !== 'production' && children.length > 1) { 18048 warn( 18049 '<transition> can only be used on a single element. Use ' + 18050 '<transition-group> for lists.', 18051 this.$parent 18052 ); 18053 } 18054 18055 var mode = this.mode; 18056 18057 // warn invalid mode 18058 if (process.env.NODE_ENV !== 'production' &&
vendor: 4,185 bytes, lines 18059-18183
18059 mode && mode !== 'in-out' && mode !== 'out-in' 18060 ) { 18061 warn( 18062 'invalid <transition> mode: ' + mode, 18063 this.$parent 18064 ); 18065 } 18066 18067 var rawChild = children[0]; 18068 18069 // if this is a component root node and the component's 18070 // parent container node also has transition, skip. 18071 if (hasParentTransition(this.$vnode)) { 18072 return rawChild 18073 } 18074 18075 // apply transition data to child 18076 // use getRealChild() to ignore abstract components e.g. keep-alive 18077 var child = getRealChild(rawChild); 18078 /* istanbul ignore if */ 18079 if (!child) { 18080 return rawChild 18081 } 18082 18083 if (this._leaving) { 18084 return placeholder(h, rawChild) 18085 } 18086 18087 // ensure a key that is unique to the vnode type and to this transition 18088 // component instance. This key will be used to remove pending leaving nodes 18089 // during entering. 18090 var id = "__transition-" + (this._uid) + "-"; 18091 child.key = child.key == null 18092 ? child.isComment 18093 ? id + 'comment' 18094 : id + child.tag 18095 : isPrimitive(child.key) 18096 ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key) 18097 : child.key; 18098 18099 var data = (child.data || (child.data = {})).transition = extractTransitionData(this); 18100 var oldRawChild = this._vnode; 18101 var oldChild = getRealChild(oldRawChild); 18102 18103 // mark v-show 18104 // so that the transition module can hand over the control to the directive 18105 if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) { 18106 child.data.show = true; 18107 } 18108 18109 if ( 18110 oldChild && 18111 oldChild.data && 18112 !isSameChild(child, oldChild) && 18113 !isAsyncPlaceholder(oldChild) && 18114 // #6687 component root is a comment node 18115 !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment) 18116 ) { 18117 // replace old child transition data with fresh one 18118 // important for dynamic transitions! 18119 var oldData = oldChild.data.transition = extend({}, data); 18120 // handle transition mode 18121 if (mode === 'out-in') { 18122 // return placeholder node and queue update when leave finishes 18123 this._leaving = true; 18124 mergeVNodeHook(oldData, 'afterLeave', function () { 18125 this$1._leaving = false; 18126 this$1.$forceUpdate(); 18127 }); 18128 return placeholder(h, rawChild) 18129 } else if (mode === 'in-out') { 18130 if (isAsyncPlaceholder(child)) { 18131 return oldRawChild 18132 } 18133 var delayedLeave; 18134 var performLeave = function () { delayedLeave(); }; 18135 mergeVNodeHook(data, 'afterEnter', performLeave); 18136 mergeVNodeHook(data, 'enterCancelled', performLeave); 18137 mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; }); 18138 } 18139 } 18140 18141 return rawChild 18142 } 18143}; 18144 18145/* */ 18146 18147// Provides transition support for list items. 18148// supports move transitions using the FLIP technique. 18149 18150// Because the vdom's children update algorithm is "unstable" - i.e. 18151// it doesn't guarantee the relative positioning of removed elements, 18152// we force transition-group to update its children into two passes: 18153// in the first pass, we remove all nodes that need to be removed, 18154// triggering their leaving transition; in the second pass, we insert/move 18155// into the final desired state. This way in the second pass removed 18156// nodes will remain where they should be. 18157 18158var props = extend({ 18159 tag: String, 18160 moveClass: String 18161}, transitionProps); 18162 18163delete props.mode; 18164 18165var TransitionGroup = { 18166 props: props, 18167 18168 render: function render (h) { 18169 var tag = this.tag || this.$vnode.data.tag || 'span'; 18170 var map = Object.create(null); 18171 var prevChildren = this.prevChildren = this.children; 18172 var rawChildren = this.$slots.default || []; 18173 var children = this.children = []; 18174 var transitionData = extractTransitionData(this); 18175 18176 for (var i = 0; i < rawChildren.length; i++) { 18177 var c = rawChildren[i]; 18178 if (c.tag) { 18179 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { 18180 children.push(c); 18181 map[c.key] = c 18182 ;(c.data || (c.data = {})).transition = transitionData; 18183 } else if (process.env.NODE_ENV !== 'production') {
vendor: 5,402 bytes, lines 18184-18367
18184 var opts = c.componentOptions; 18185 var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag; 18186 warn(("<transition-group> children must be keyed: <" + name + ">")); 18187 } 18188 } 18189 } 18190 18191 if (prevChildren) { 18192 var kept = []; 18193 var removed = []; 18194 for (var i$1 = 0; i$1 < prevChildren.length; i$1++) { 18195 var c$1 = prevChildren[i$1]; 18196 c$1.data.transition = transitionData; 18197 c$1.data.pos = c$1.elm.getBoundingClientRect(); 18198 if (map[c$1.key]) { 18199 kept.push(c$1); 18200 } else { 18201 removed.push(c$1); 18202 } 18203 } 18204 this.kept = h(tag, null, kept); 18205 this.removed = removed; 18206 } 18207 18208 return h(tag, null, children) 18209 }, 18210 18211 beforeUpdate: function beforeUpdate () { 18212 // force removing pass 18213 this.__patch__( 18214 this._vnode, 18215 this.kept, 18216 false, // hydrating 18217 true // removeOnly (!important, avoids unnecessary moves) 18218 ); 18219 this._vnode = this.kept; 18220 }, 18221 18222 updated: function updated () { 18223 var children = this.prevChildren; 18224 var moveClass = this.moveClass || ((this.name || 'v') + '-move'); 18225 if (!children.length || !this.hasMove(children[0].elm, moveClass)) { 18226 return 18227 } 18228 18229 // we divide the work into three loops to avoid mixing DOM reads and writes 18230 // in each iteration - which helps prevent layout thrashing. 18231 children.forEach(callPendingCbs); 18232 children.forEach(recordPosition); 18233 children.forEach(applyTranslation); 18234 18235 // force reflow to put everything in position 18236 // assign to this to avoid being removed in tree-shaking 18237 // $flow-disable-line 18238 this._reflow = document.body.offsetHeight; 18239 18240 children.forEach(function (c) { 18241 if (c.data.moved) { 18242 var el = c.elm; 18243 var s = el.style; 18244 addTransitionClass(el, moveClass); 18245 s.transform = s.WebkitTransform = s.transitionDuration = ''; 18246 el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { 18247 if (!e || /transform$/.test(e.propertyName)) { 18248 el.removeEventListener(transitionEndEvent, cb); 18249 el._moveCb = null; 18250 removeTransitionClass(el, moveClass); 18251 } 18252 }); 18253 } 18254 }); 18255 }, 18256 18257 methods: { 18258 hasMove: function hasMove (el, moveClass) { 18259 /* istanbul ignore if */ 18260 if (!hasTransition) { 18261 return false 18262 } 18263 /* istanbul ignore if */ 18264 if (this._hasMove) { 18265 return this._hasMove 18266 } 18267 // Detect whether an element with the move class applied has 18268 // CSS transitions. Since the element may be inside an entering 18269 // transition at this very moment, we make a clone of it and remove 18270 // all other transition classes applied to ensure only the move class 18271 // is applied. 18272 var clone = el.cloneNode(); 18273 if (el._transitionClasses) { 18274 el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); }); 18275 } 18276 addClass(clone, moveClass); 18277 clone.style.display = 'none'; 18278 this.$el.appendChild(clone); 18279 var info = getTransitionInfo(clone); 18280 this.$el.removeChild(clone); 18281 return (this._hasMove = info.hasTransform) 18282 } 18283 } 18284}; 18285 18286function callPendingCbs (c) { 18287 /* istanbul ignore if */ 18288 if (c.elm._moveCb) { 18289 c.elm._moveCb(); 18290 } 18291 /* istanbul ignore if */ 18292 if (c.elm._enterCb) { 18293 c.elm._enterCb(); 18294 } 18295} 18296 18297function recordPosition (c) { 18298 c.data.newPos = c.elm.getBoundingClientRect(); 18299} 18300 18301function applyTranslation (c) { 18302 var oldPos = c.data.pos; 18303 var newPos = c.data.newPos; 18304 var dx = oldPos.left - newPos.left; 18305 var dy = oldPos.top - newPos.top; 18306 if (dx || dy) { 18307 c.data.moved = true; 18308 var s = c.elm.style; 18309 s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)"; 18310 s.transitionDuration = '0s'; 18311 } 18312} 18313 18314var platformComponents = { 18315 Transition: Transition, 18316 TransitionGroup: TransitionGroup 18317}; 18318 18319/* */ 18320 18321// install platform specific utils 18322Vue$3.config.mustUseProp = mustUseProp; 18323Vue$3.config.isReservedTag = isReservedTag; 18324Vue$3.config.isReservedAttr = isReservedAttr; 18325Vue$3.config.getTagNamespace = getTagNamespace; 18326Vue$3.config.isUnknownElement = isUnknownElement; 18327 18328// install platform runtime directives & components 18329extend(Vue$3.options.directives, platformDirectives); 18330extend(Vue$3.options.components, platformComponents); 18331 18332// install platform patch function 18333Vue$3.prototype.__patch__ = inBrowser ? patch : noop; 18334 18335// public mount method 18336Vue$3.prototype.$mount = function ( 18337 el, 18338 hydrating 18339) { 18340 el = el && inBrowser ? query(el) : undefined; 18341 return mountComponent(this, el, hydrating) 18342}; 18343 18344// devtools global hook 18345/* istanbul ignore next */ 18346Vue$3.nextTick(function () { 18347 if (config.devtools) { 18348 if (devtools) { 18349 devtools.emit('init', Vue$3); 18350 } else if (process.env.NODE_ENV !== 'production' && isChrome) { 18351 console[console.info ? 'info' : 'log']( 18352 'Download the Vue Devtools extension for a better development experience:\n' + 18353 'https://github.com/vuejs/vue-devtools' 18354 ); 18355 } 18356 } 18357 if (process.env.NODE_ENV !== 'production' && 18358 config.productionTip !== false && 18359 inBrowser && typeof console !== 'undefined' 18360 ) { 18361 console[console.info ? 'info' : 'log']( 18362 "You are running Vue in development mode.\n" + 18363 "Make sure to turn on production mode when deploying for production.\n" + 18364 "See more tips at https://vuejs.org/guide/deployment.html" 18365 ); 18366 } 18367}
18367, 0); 18368 18369/* */ 18370 18371var defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g; 18372var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; 18373 18374var buildRegex = cached(function (delimiters) { 18375 var open = delimiters[0].replace(regexEscapeRE, '\\$&'); 18376 var close = delimiters[1].replace(regexEscapeRE, '\\$&'); 18377 return new RegExp(open + '((?:.|\\n)+?)' + close, 'g') 18378}); 18379 18380function parseText ( 18381 text, 18382 delimiters 18383) { 18384 var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; 18385 if (!tagRE.test(text)) { 18386 return 18387 } 18388 var tokens = []; 18389 var lastIndex = tagRE.lastIndex = 0; 18390 var match, index; 18391 while ((match = tagRE.exec(text))) { 18392 index = match.index; 18393 // push text token 18394 if (index > lastIndex) { 18395 tokens.push(JSON.stringify(text.slice(lastIndex, index))); 18396 } 18397 // tag token 18398 var exp = parseFilters(match[1].trim()); 18399 tokens.push(("_s(" + exp + ")")); 18400 lastIndex = index + match[0].length; 18401 } 18402 if (lastIndex < text.length) { 18403 tokens.push(JSON.stringify(text.slice(lastIndex))); 18404 } 18405 return tokens.join('+') 18406} 18407 18408/* */ 18409 18410function transformNode (el, options) { 18411 var warn = options.warn || baseWarn; 18412 var staticClass = getAndRemoveAttr(el, 'class'); 18413 if (process.env.NODE_ENV !== 'production' && staticClass) { 18414 var expression = parseText(staticClass, options.delimiters); 18415 if (expression) { 18416 warn( 18417 "class=\"" + staticClass + "\": " + 18418 'Interpolation inside attributes has been removed. ' + 18419 'Use v-bind or the colon shorthand instead. For example, ' + 18420 'instead of <div class="{{ val }}">, use <div :class="val">.' 18421 ); 18422 } 18423 } 18424 if (staticClass) { 18425 el.staticClass = JSON.stringify(staticClass); 18426 } 18427 var classBinding = getBindingAttr(el, 'class', false /* getStatic */); 18428 if (classBinding) { 18429 el.classBinding = classBinding; 18430 } 18431} 18432 18433function genData (el) { 18434 var data = ''; 18435 if (el.staticClass) { 18436 data += "staticClass:" + (el.staticClass) + ","; 18437 } 18438 if (el.classBinding) { 18439 data += "class:" + (el.classBinding) + ","; 18440 } 18441 return data 18442} 18443 18444var klass$1 = { 18445 staticKeys: ['staticClass'], 18446 transformNode: transformNode, 18447 genData: genData 18448}; 18449 18450/* */ 18451 18452function transformNode$1 (el, options) { 18453 var warn = options.warn || baseWarn; 18454 var staticStyle = getAndRemoveAttr(el, 'style'); 18455 if (staticStyle) { 18456 /* istanbul ignore if */ 18457 if (process.env.NODE_ENV !== 'production') { 18458 var expression = parseText(staticStyle, options.delimiters); 18459 if (expression) { 18460 warn( 18461 "style=\"" + staticStyle + "\": " + 18462 'Interpolation inside attributes has been removed. ' + 18463 'Use v-bind or the colon shorthand instead. For example, ' + 18464 'instead of <div style="{{ val }}">, use <div :style="val">.' 18465 ); 18466 } 18467 } 18468 el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); 18469 } 18470 18471 var styleBinding = getBindingAttr(el, 'style', false /* getStatic */); 18472 if (styleBinding) { 18473 el.styleBinding = styleBinding; 18474 } 18475} 18476 18477function genData$1 (el) { 18478 var data = ''; 18479 if (el.staticStyle) { 18480 data += "staticStyle:" + (el.staticStyle) + ","; 18481 } 18482 if (el.styleBinding) { 18483 data += "style:(" + (el.styleBinding) + "),"; 18484 } 18485 return data 18486} 18487 18488var style$1 = { 18489 staticKeys: ['staticStyle'], 18490 transformNode: transformNode$1, 18491 genData: genData$1 18492}; 18493 18494/* */ 18495 18496var decoder; 18497 18498var he = { 18499 decode: function decode (html) { 18500 decoder = decoder || document.createElement('div'); 18501 decoder.innerHTML = html; 18502 return decoder.textContent 18503 } 18504}; 18505 18506/* */ 18507 18508var isUnaryTag = makeMap( 18509 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 18510 'link,meta,param,source,track,wbr' 18511); 18512 18513// Elements that you can, intentionally, leave open 18514// (and which close themselves) 18515var canBeLeftOpenTag = makeMap( 18516 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source' 18517); 18518 18519// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 18520// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content 18521var isNonPhrasingTag = makeMap( 18522 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 18523 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 18524 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 18525 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 18526 'title,tr,track' 18527); 18528 18529/** 18530 * Not type-checking this file because it's mostly vendor code. 18531 */ 18532 18533/*! 18534 * HTML Parser By John Resig (ejohn.org) 18535 * Modified by Juriy "kangax" Zaytsev
18536 * Original code by Erik Arvidsson, Mozilla Public License 18537 * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js 18538 */ 18539 18540// Regular Expressions for parsing tags and attributes 18541var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 18542// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName 18543// but for Vue templates we can enforce a simple charset 18544var ncname = '[a-zA-Z_][\\w\\-\\.]*'; 18545var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")"; 18546var startTagOpen = new RegExp(("^<" + qnameCapture)); 18547var startTagClose = /^\s*(\/?)>/; 18548var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>")); 18549var doctype = /^<!DOCTYPE [^>]+>/i; 18550var comment = /^<!--/; 18551var conditionalComment = /^<!\[/; 18552 18553var IS_REGEX_CAPTURING_BROKEN = false; 18554'x'.replace(/x(.)?/g, function (m, g) { 18555 IS_REGEX_CAPTURING_BROKEN = g === ''; 18556}); 18557 18558// Special Elements (can contain anything) 18559var isPlainTextElement = makeMap('script,style,textarea', true); 18560var reCache = {}; 18561 18562var decodingMap = { 18563 '<': '<', 18564 '>': '>', 18565 '"': '"', 18566 '&': '&', 18567 ' ': '\n', 18568 '	': '\t' 18569}; 18570var encodedAttr = /&(?:lt|gt|quot|amp);/g; 18571var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g; 18572 18573// #5992 18574var isIgnoreNewlineTag = makeMap('pre,textarea', true); 18575var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; }; 18576 18577function decodeAttr (value, shouldDecodeNewlines) { 18578 var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; 18579 return value.replace(re, function (match) { return decodingMap[match]; }) 18580} 18581 18582function parseHTML (html, options) { 18583 var stack = []; 18584 var expectHTML = options.expectHTML; 18585 var isUnaryTag$$1 = options.isUnaryTag || no; 18586 var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; 18587 var index = 0; 18588 var last, lastTag; 18589 while (html) { 18590 last = html; 18591 // Make sure we're not in a plaintext content element like script/style 18592 if (!lastTag || !isPlainTextElement(lastTag)) { 18593 var textEnd = html.indexOf('<'); 18594 if (textEnd === 0) { 18595 // Comment: 18596 if (comment.test(html)) { 18597 var commentEnd = html.indexOf('-->'); 18598 18599 if (commentEnd >= 0) { 18600 if (options.shouldKeepComment) { 18601 options.comment(html.substring(4, commentEnd)); 18602 } 18603 advance(commentEnd + 3); 18604 continue 18605 } 18606 } 18607 18608 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment 18609 if (conditionalComment.test(html)) { 18610 var conditionalEnd = html.indexOf(']>'); 18611 18612 if (conditionalEnd >= 0) { 18613 advance(conditionalEnd + 2); 18614 continue 18615 } 18616 } 18617 18618 // Doctype: 18619 var doctypeMatch = html.match(doctype); 18620 if (doctypeMatch) { 18621 advance(doctypeMatch[0].length); 18622 continue 18623 } 18624 18625 // End tag: 18626 var endTagMatch = html.match(endTag); 18627 if (endTagMatch) { 18628 var curIndex = index; 18629 advance(endTagMatch[0].length); 18630 parseEndTag(endTagMatch[1], curIndex, index); 18631 continue 18632 } 18633 18634 // Start tag: 18635 var startTagMatch = parseStartTag(); 18636 if (startTagMatch) { 18637 handleStartTag(startTagMatch); 18638 if (shouldIgnoreFirstNewline(lastTag, html)) { 18639 advance(1); 18640 } 18641 continue 18642 } 18643 } 18644 18645 var text = (void 0), rest = (void 0), next = (void 0); 18646 if (textEnd >= 0) { 18647 rest = html.slice(textEnd); 18648 while ( 18649 !endTag.test(rest) && 18650 !startTagOpen.test(rest) && 18651 !comment.test(rest) && 18652 !conditionalComment.test(rest) 18653 ) { 18654 // < in plain text, be forgiving and treat it as text 18655 next = rest.indexOf('<', 1); 18656 if (next < 0) { break } 18657 textEnd += next; 18658 rest = html.slice(textEnd); 18659 } 18660 text = html.substring(0, textEnd); 18661 advance(textEnd); 18662 } 18663 18664 if (textEnd < 0) { 18665 text = html; 18666 html = ''; 18667 } 18668 18669 if (options.chars && text) { 18670 options.chars(text); 18671 } 18672 } else { 18673 var endTagLength = 0; 18674 var stackedTag = lastTag.toLowerCase(); 18675 var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')); 18676 var rest$1 = html.replace(reStackedTag, function (all, text, endTag) { 18677 endTagLength = endTag.length; 18678 if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') { 18679 text = text 18680 .replace(/<!--([\s\S]*?)-->/g, '$1') 18681 .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1'); 18682 } 18683 if (shouldIgnoreFirstNewline(stackedTag, text)) { 18684 text = text.slice(1); 18685 } 18686 if (options.chars) { 18687 options.chars(text); 18688 } 18689 return '' 18690 }); 18691 index += html.length - rest$1.length; 18692 html = rest$1; 18693 parseEndTag(stackedTag, index - endTagLength, index); 18694 } 18695 18696 if (html === last) { 18697 options.chars && options.chars(html); 18698 if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) { 18699 options.warn(("Mal-formatted tag at end of template: \"" + html + "\"")); 18700 } 18701 break 18702 } 18703 } 18704 18705 // Clean up any remaining tags 18706 parseEndTag(); 18707 18708 function advance (n) { 18709 index += n; 18710 html = html.substring(n); 18711 } 18712 18713 function parseStartTag () { 18714 var start = html.match(startTagOpen); 18715 if (start) { 18716 var match = { 18717 tagName: start[1], 18718 attrs: [], 18719 start: index 18720 }; 18721 advance(start[0].length); 18722 var end, attr; 18723 while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) { 18724 advance(attr[0].length); 18725 match.attrs.push(attr); 18726 } 18727 if (end) { 18728 match.unarySlash = end[1]; 18729 advance(end[0].length); 18730 match.end = index; 18731 return match 18732 } 18733 } 18734 } 18735 18736 function handleStartTag (match) { 18737 var tagName = match.tagName; 18738 var unarySlash = match.unarySlash; 18739 18740 if (expectHTML) { 18741 if (lastTag === 'p' && isNonPhrasingTag(tagName)) { 18742 parseEndTag(lastTag); 18743 } 18744 if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) { 18745 parseEndTag(tagName); 18746 } 18747 } 18748 18749 var unary = isUnaryTag$$1(tagName) || !!unarySlash; 18750 18751 var l = match.attrs.length; 18752 var attrs = new Array(l); 18753 for (var i = 0; i < l; i++) { 18754 var args = match.attrs[i]; 18755 // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778 18756 if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) { 18757 if (args[3] === '') { delete args[3]; } 18758 if (args[4] === '') { delete args[4]; } 18759 if (args[5] === '') { delete args[5]; } 18760 } 18761 var value = args[3] || args[4] || args[5] || ''; 18762 var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' 18763 ? options.shouldDecodeNewlinesForHref 18764 : options.shouldDecodeNewlines; 18765 attrs[i] = { 18766 name: args[1], 18767 value: decodeAttr(value, shouldDecodeNewlines) 18768 }; 18769 } 18770 18771 if (!unary) { 18772 stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs }); 18773 lastTag = tagName; 18774 } 18775 18776 if (options.start) { 18777 options.start(tagName, attrs, unary, match.start, match.end); 18778 } 18779 } 18780 18781 function parseEndTag (tagName, start, end) { 18782 var pos, lowerCasedTagName; 18783 if (start == null) { start = index; } 18784 if (end == null) { end = index; } 18785 18786 if (tagName) { 18787 lowerCasedTagName = tagName.toLowerCase(); 18788 } 18789 18790 // Find the closest opened tag of the same type 18791 if (tagName) { 18792 for (pos = stack.length - 1; pos >= 0; pos--) { 18793 if (stack[pos].lowerCasedTag === lowerCasedTagName) { 18794 break 18795 } 18796 } 18797 } else { 18798 // If no tag name is provided, clean shop 18799 pos = 0; 18800 } 18801 18802 if (pos >= 0) { 18803 // Close all the open elements, up the stack 18804 for (var i = stack.length - 1; i >= pos; i--) { 18805 if (process.env.NODE_ENV !== 'production' && 18806 (i > pos || !tagName) && 18807 options.warn 18808 ) { 18809 options.warn( 18810 ("tag <" + (stack[i].tag) + "> has no matching end tag.") 18811 ); 18812 } 18813 if (options.end) { 18814 options.end(stack[i].tag, start, end); 18815 } 18816 } 18817 18818 // Remove the open elements from the stack 18819 stack.length = pos; 18820 lastTag = pos && stack[pos - 1].tag; 18821 } else if (lowerCasedTagName === 'br') { 18822 if (options.start) { 18823 options.start(tagName, [], true, start, end); 18824 } 18825 } else if (lowerCasedTagName === 'p') { 18826 if (options.start) { 18827 options.start(tagName, [], false, start, end); 18828 } 18829 if (options.end) { 18830 options.end(tagName, start, end); 18831 } 18832 } 18833 } 18834} 18835 18836/* */ 18837 18838var onRE = /^@|^v-on:/; 18839var dirRE = /^v-|^@|^:/; 18840var forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/; 18841var forIteratorRE = /\((\{[^}]*\}|[^,]*),([^,]*)(?:,([^,]*))?\)/; 18842 18843var argRE = /:(.*)$/; 18844var bindRE = /^:|^v-bind:/; 18845var modifierRE = /\.[^.]+/g; 18846
18847var decodeHTMLCached = cached(he.decode); 18848 18849// configurable state 18850var warn$2; 18851var delimiters; 18852var transforms; 18853var preTransforms; 18854var postTransforms; 18855var platformIsPreTag; 18856var platformMustUseProp; 18857var platformGetTagNamespace; 18858 18859 18860 18861function createASTElement ( 18862 tag, 18863 attrs, 18864 parent 18865) { 18866 return { 18867 type: 1, 18868 tag: tag, 18869 attrsList: attrs, 18870 attrsMap: makeAttrsMap(attrs), 18871 parent: parent, 18872 children: [] 18873 } 18874} 18875 18876/** 18877 * Convert HTML string to AST. 18878 */ 18879function parse ( 18880 template, 18881 options 18882) { 18883 warn$2 = options.warn || baseWarn; 18884 18885 platformIsPreTag = options.isPreTag || no; 18886 platformMustUseProp = options.mustUseProp || no; 18887 platformGetTagNamespace = options.getTagNamespace || no; 18888 18889 transforms = pluckModuleFunction(options.modules, 'transformNode'); 18890 preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); 18891 postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); 18892 18893 delimiters = options.delimiters; 18894 18895 var stack = []; 18896 var preserveWhitespace = options.preserveWhitespace !== false; 18897 var root; 18898 var currentParent; 18899 var inVPre = false; 18900 var inPre = false; 18901 var warned = false; 18902 18903 function warnOnce (msg) { 18904 if (!warned) { 18905 warned = true; 18906 warn$2(msg); 18907 } 18908 } 18909 18910 function endPre (element) { 18911 // check pre state 18912 if (element.pre) { 18913 inVPre = false; 18914 } 18915 if (platformIsPreTag(element.tag)) { 18916 inPre = false; 18917 } 18918 } 18919 18920 parseHTML(template, { 18921 warn: warn$2, 18922 expectHTML: options.expectHTML, 18923 isUnaryTag: options.isUnaryTag, 18924 canBeLeftOpenTag: options.canBeLeftOpenTag, 18925 shouldDecodeNewlines: options.shouldDecodeNewlines, 18926 shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, 18927 shouldKeepComment: options.comments, 18928 start: function start (tag, attrs, unary) { 18929 // check namespace. 18930 // inherit parent ns if there is one 18931 var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); 18932 18933 // handle IE svg bug 18934 /* istanbul ignore if */ 18935 if (isIE && ns === 'svg') { 18936 attrs = guardIESVGBug(attrs); 18937 } 18938 18939 var element = createASTElement(tag, attrs, currentParent); 18940 if (ns) { 18941 element.ns = ns; 18942 } 18943 18944 if (isForbiddenTag(element) && !isServerRendering()) { 18945 element.forbidden = true; 18946 process.env.NODE_ENV !== 'production' && warn$2( 18947 'Templates should only be responsible for mapping the state to the ' + 18948 'UI. Avoid placing tags with side-effects in your templates, such as ' + 18949 "<" + tag + ">" + ', as they will not be parsed.' 18950 ); 18951 } 18952 18953 // apply pre-transforms 18954 for (var i = 0; i < preTransforms.length; i++) { 18955 element = preTransforms[i](element, options) || element; 18956 } 18957 18958 if (!inVPre) { 18959 processPre(element); 18960 if (element.pre) { 18961 inVPre = true; 18962 } 18963 } 18964 if (platformIsPreTag(element.tag)) { 18965 inPre = true; 18966 } 18967 if (inVPre) { 18968 processRawAttrs(element); 18969 } else if (!element.processed) { 18970 // structural directives 18971 processFor(element); 18972 processIf(element); 18973 processOnce(element); 18974 // element-scope stuff 18975 processElement(element, options); 18976 } 18977 18978 function checkRootConstraints (el) { 18979 if (process.env.NODE_ENV !== 'production') { 18980 if (el.tag === 'slot' || el.tag === 'template') { 18981 warnOnce( 18982 "Cannot use <" + (el.tag) + "> as component root element because it may " + 18983 'contain multiple nodes.' 18984 ); 18985 } 18986 if (el.attrsMap.hasOwnProperty('v-for')) { 18987 warnOnce( 18988 'Cannot use v-for on stateful component root element because ' + 18989 'it renders multiple elements.' 18990 ); 18991 } 18992 } 18993 } 18994 18995 // tree management 18996 if (!root) { 18997 root = element; 18998 checkRootConstraints(root); 18999 } else if (!stack.length) { 19000 // allow root elements with v-if, v-else-if and v-else 19001 if (root.if && (element.elseif || element.else)) { 19002 checkRootConstraints(element); 19003 addIfCondition(root, { 19004 exp: element.elseif, 19005 block: element 19006 }); 19007 } else if (process.env.NODE_ENV !== 'production') { 19008 warnOnce( 19009 "Component template should contain exactly one root element. " + 19010 "If you are using v-if on multiple elements, " + 19011 "use v-else-if to chain them instead." 19012 ); 19013 } 19014 } 19015 if (currentParent && !element.forbidden) { 19016 if (element.elseif || element.else) { 19017 processIfConditions(element, currentParent); 19018 } else if (element.slotScope) { // scoped slot 19019 currentParent.plain = false;
19020 var name = element.slotTarget || '"default"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element; 19021 } else { 19022 currentParent.children.push(element); 19023 element.parent = currentParent; 19024 } 19025 } 19026 if (!unary) { 19027 currentParent = element; 19028 stack.push(element); 19029 } else { 19030 endPre(element); 19031 } 19032 // apply post-transforms 19033 for (var i$1 = 0; i$1 < postTransforms.length; i$1++) { 19034 postTransforms[i$1](element, options); 19035 } 19036 }, 19037 19038 end: function end () { 19039 // remove trailing whitespace 19040 var element = stack[stack.length - 1]; 19041 var lastNode = element.children[element.children.length - 1]; 19042 if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) { 19043 element.children.pop(); 19044 } 19045 // pop stack 19046 stack.length -= 1; 19047 currentParent = stack[stack.length - 1]; 19048 endPre(element); 19049 }, 19050 19051 chars: function chars (text) { 19052 if (!currentParent) { 19053 if (process.env.NODE_ENV !== 'production') { 19054 if (text === template) { 19055 warnOnce( 19056 'Component template requires a root element, rather than just text.' 19057 ); 19058 } else if ((text = text.trim())) { 19059 warnOnce( 19060 ("text \"" + text + "\" outside root element will be ignored.") 19061 ); 19062 } 19063 } 19064 return 19065 } 19066 // IE textarea placeholder bug 19067 /* istanbul ignore if */ 19068 if (isIE && 19069 currentParent.tag === 'textarea' && 19070 currentParent.attrsMap.placeholder === text 19071 ) { 19072 return 19073 } 19074 var children = currentParent.children; 19075 text = inPre || text.trim() 19076 ? isTextTag(currentParent) ? text : decodeHTMLCached(text) 19077 // only preserve whitespace if its not right after a starting tag 19078 : preserveWhitespace && children.length ? ' ' : ''; 19079 if (text) { 19080 var expression; 19081 if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) { 19082 children.push({ 19083 type: 2, 19084 expression: expression, 19085 text: text 19086 }); 19087 } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') { 19088 children.push({ 19089 type: 3, 19090 text: text 19091 }); 19092 } 19093 } 19094 }, 19095 comment: function comment (text) { 19096 currentParent.children.push({ 19097 type: 3, 19098 text: text, 19099 isComment: true 19100 }); 19101 } 19102 }); 19103 return root 19104} 19105 19106function processPre (el) { 19107 if (getAndRemoveAttr(el, 'v-pre') != null) { 19108 el.pre = true; 19109 } 19110} 19111 19112function processRawAttrs (el) { 19113 var l = el.attrsList.length; 19114 if (l) { 19115 var attrs = el.attrs = new Array(l); 19116 for (var i = 0; i < l; i++) { 19117 attrs[i] = { 19118 name: el.attrsList[i].name, 19119 value: JSON.stringify(el.attrsList[i].value) 19120 }; 19121 } 19122 } else if (!el.pre) { 19123 // non root node in pre blocks with no attributes 19124 el.plain = true; 19125 } 19126} 19127 19128function processElement (element, options) { 19129 processKey(element); 19130 19131 // determine whether this is a plain element after 19132 // removing structural attributes 19133 element.plain = !element.key && !element.attrsList.length; 19134 19135 processRef(element); 19136 processSlot(element); 19137 processComponent(element); 19138 for (var i = 0; i < transforms.length; i++) { 19139 element = transforms[i](element, options) || element; 19140 } 19141 processAttrs(element); 19142} 19143 19144function processKey (el) { 19145 var exp = getBindingAttr(el, 'key'); 19146 if (exp) { 19147 if (process.env.NODE_ENV !== 'production' && el.tag === 'template') { 19148 warn$2("<template> cannot be keyed. Place the key on real elements instead."); 19149 } 19150 el.key = exp; 19151 } 19152} 19153 19154function processRef (el) { 19155 var ref = getBindingAttr(el, 'ref'); 19156 if (ref) { 19157 el.ref = ref; 19158 el.refInFor = checkInFor(el); 19159 } 19160} 19161 19162function processFor (el) { 19163 var exp; 19164 if ((exp = getAndRemoveAttr(el, 'v-for'))) { 19165 var inMatch = exp.match(forAliasRE); 19166 if (!inMatch) { 19167 process.env.NODE_ENV !== 'production' && warn$2( 19168 ("Invalid v-for expression: " + exp) 19169 ); 19170 return 19171 } 19172 el.for = inMatch[2].trim(); 19173 var alias = inMatch[1].trim(); 19174 var iteratorMatch = alias.match(forIteratorRE); 19175 if (iteratorMatch) { 19176 el.alias = iteratorMatch[1].trim(); 19177 el.iterator1 = iteratorMatch[2].trim(); 19178 if (iteratorMatch[3]) { 19179 el.iterator2 = iteratorMatch[3].trim(); 19180 } 19181 } else { 19182 el.alias = alias; 19183 } 19184 } 19185} 19186 19187function processIf (el) { 19188 var exp = getAndRemoveAttr(el, 'v-if'); 19189 if (exp) { 19190 el.if = exp; 19191 addIfCondition(el, { 19192 exp: exp, 19193 block: el 19194 }); 19195 } else { 19196 if (getAndRemoveAttr(el, 'v-else') != null) { 19197 el.else = true; 19198 } 19199 var elseif = getAndRemoveAttr(el, 'v-else-if'); 19200 if (elseif) { 19201 el.elseif = elseif; 19202 } 19203 } 19204} 19205 19206function processIfConditions (el, parent) { 19207 var prev = findPrevElement(parent.children); 19208 if (prev && prev.if) { 19209 addIfCondition(prev, { 19210 exp: el.elseif, 19211 block: el 19212 }); 19213 } else if (process.env.NODE_ENV !== 'production') { 19214 warn$2( 19215 "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " + 19216 "used on element <" + (el.tag) + "> without corresponding v-if." 19217 ); 19218 } 19219} 19220 19221function findPrevElement (children) { 19222 var i = children.length; 19223 while (i--) { 19224 if (children[i].type === 1) { 19225 return children[i] 19226 } else { 19227 if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') { 19228 warn$2( 19229 "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " + 19230 "will be ignored." 19231 ); 19232 } 19233 children.pop(); 19234 } 19235 } 19236} 19237 19238function addIfCondition (el, condition) { 19239 if (!el.ifConditions) { 19240 el.ifConditions = []; 19241 } 19242 el.ifConditions.push(condition); 19243} 19244 19245function processOnce (el) { 19246 var once$$1 = getAndRemoveAttr(el, 'v-once'); 19247 if (once$$1 != null) { 19248 el.once = true; 19249 } 19250} 19251 19252function processSlot (el) { 19253 if (el.tag === 'slot') { 19254 el.slotName = getBindingAttr(el, 'name'); 19255 if (process.env.NODE_ENV !== 'production' && el.key) { 19256 warn$2( 19257 "`key` does not work on <slot> because slots are abstract outlets " + 19258 "and can possibly expand into multiple elements. " + 19259 "Use the key on a wrapping element instead." 19260 ); 19261 } 19262 } else { 19263 var slotScope; 19264 if (el.tag === 'template') { 19265 slotScope = getAndRemoveAttr(el, 'scope'); 19266 /* istanbul ignore if */ 19267 if (process.env.NODE_ENV !== 'production' && slotScope) { 19268 warn$2( 19269 "the \"scope\" attribute for scoped slots have been deprecated and " + 19270 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " + 19271 "can also be used on plain elements in addition to <template> to " + 19272 "denote scoped slots.", 19273 true 19274 ); 19275 } 19276 el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope'); 19277 } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { 19278 /* istanbul ignore if */ 19279 if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) { 19280 warn$2( 19281 "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " + 19282 "(v-for takes higher priority). Use a wrapper <template> for the " + 19283 "scoped slot to make it clearer.", 19284 true 19285 ); 19286 } 19287 el.slotScope = slotScope; 19288 } 19289 var slotTarget = getBindingAttr(el, 'slot'); 19290 if (slotTarget) { 19291 el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; 19292 // preserve slot as an attribute for native shadow DOM compat 19293 // only for non-scoped slots. 19294 if (el.tag !== 'template' && !el.slotScope) { 19295 addAttr(el, 'slot', slotTarget); 19296 } 19297 } 19298 } 19299} 19300 19301function processComponent (el) { 19302 var binding; 19303 if ((binding = getBindingAttr(el, 'is'))) { 19304 el.component = binding; 19305 } 19306 if (getAndRemoveAttr(el, 'inline-template') != null) { 19307 el.inlineTemplate = true; 19308 } 19309} 19310 19311function processAttrs (el) { 19312 var list = el.attrsList; 19313 var i, l, name, rawName, value, modifiers, isProp; 19314 for (i = 0, l = list.length; i < l; i++) { 19315 name = rawName = list[i].name; 19316 value = list[i].value; 19317 if (dirRE.test(name)) { 19318 // mark element as dynamic 19319 el.hasBindings = true; 19320 // modifiers 19321 modifiers = parseModifiers(name); 19322 if (modifiers) { 19323 name = name.replace(modifierRE, ''); 19324 } 19325 if (bindRE.test(name)) { // v-bind 19326 name = name.replace(bindRE, ''); 19327 value = parseFilters(value); 19328 isProp = false;
19329 if (modifiers) { 19330 if (modifiers.prop) { 19331 isProp = true; 19332 name = camelize(name); 19333 if (name === 'innerHtml') { name = 'innerHTML'; } 19334 } 19335 if (modifiers.camel) { 19336 name = camelize(name); 19337 } 19338 if (modifiers.sync) { 19339 addHandler( 19340 el, 19341 ("update:" + (camelize(name))), 19342 genAssignmentCode(value, "$event") 19343 ); 19344 } 19345 } 19346 if (isProp || ( 19347 !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name) 19348 )) { 19349 addProp(el, name, value); 19350 } else { 19351 addAttr(el, name, value); 19352 } 19353 } else if (onRE.test(name)) { // v-on 19354 name = name.replace(onRE, ''); 19355 addHandler(el, name, value, modifiers, false, warn$2); 19356 } else { // normal directives 19357 name = name.replace(dirRE, ''); 19358 // parse arg 19359 var argMatch = name.match(argRE); 19360 var arg = argMatch && argMatch[1]; 19361 if (arg) { 19362 name = name.slice(0, -(arg.length + 1)); 19363 } 19364 addDirective(el, name, rawName, value, arg, modifiers); 19365 if (process.env.NODE_ENV !== 'production' && name === 'model') { 19366 checkForAliasModel(el, value); 19367 } 19368 } 19369 } else { 19370 // literal attribute 19371 if (process.env.NODE_ENV !== 'production') { 19372 var expression = parseText(value, delimiters); 19373 if (expression) { 19374 warn$2( 19375 name + "=\"" + value + "\": " + 19376 'Interpolation inside attributes has been removed. ' + 19377 'Use v-bind or the colon shorthand instead. For example, ' + 19378 'instead of <div id="{{ val }}">, use <div :id="val">.' 19379 ); 19380 } 19381 } 19382 addAttr(el, name, JSON.stringify(value)); 19383 // #6887 firefox doesn't update muted state if set via attribute 19384 // even immediately after element creation 19385 if (!el.component && 19386 name === 'muted' && 19387 platformMustUseProp(el.tag, el.attrsMap.type, name)) { 19388 addProp(el, name, 'true'); 19389 } 19390 } 19391 } 19392} 19393 19394function checkInFor (el) { 19395 var parent = el; 19396 while (parent) { 19397 if (parent.for !== undefined) { 19398 return true 19399 } 19400 parent = parent.parent; 19401 } 19402 return false 19403} 19404 19405function parseModifiers (name) { 19406 var match = name.match(modifierRE); 19407 if (match) { 19408 var ret = {}; 19409 match.forEach(function (m) { ret[m.slice(1)] = true; }); 19410 return ret 19411 } 19412} 19413 19414function makeAttrsMap (attrs) { 19415 var map = {}; 19416 for (var i = 0, l = attrs.length; i < l; i++) { 19417 if ( 19418 process.env.NODE_ENV !== 'production' && 19419 map[attrs[i].name] && !isIE && !isEdge 19420 ) { 19421 warn$2('duplicate attribute: ' + attrs[i].name); 19422 } 19423 map[attrs[i].name] = attrs[i].value; 19424 } 19425 return map 19426} 19427 19428// for script (e.g. type="x/template") or style, do not decode content 19429function isTextTag (el) { 19430 return el.tag === 'script' || el.tag === 'style' 19431} 19432 19433function isForbiddenTag (el) { 19434 return ( 19435 el.tag === 'style' || 19436 (el.tag === 'script' && ( 19437 !el.attrsMap.type || 19438 el.attrsMap.type === 'text/javascript' 19439 )) 19440 ) 19441} 19442 19443var ieNSBug = /^xmlns:NS\d+/; 19444var ieNSPrefix = /^NS\d+:/; 19445 19446/* istanbul ignore next */ 19447function guardIESVGBug (attrs) { 19448 var res = []; 19449 for (var i = 0; i < attrs.length; i++) { 19450 var attr = attrs[i]; 19451 if (!ieNSBug.test(attr.name)) { 19452 attr.name = attr.name.replace(ieNSPrefix, ''); 19453 res.push(attr); 19454 } 19455 } 19456 return res 19457} 19458 19459function checkForAliasModel (el, value) { 19460 var _el = el; 19461 while (_el) { 19462 if (_el.for && _el.alias === value) { 19463 warn$2( 19464 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 19465 "You are binding v-model directly to a v-for iteration alias. " + 19466 "This will not be able to modify the v-for source array because " + 19467 "writing to the alias is like modifying a function local variable. " + 19468 "Consider using an array of objects and use v-model on an object property instead." 19469 ); 19470 } 19471 _el = _el.parent; 19472 } 19473} 19474 19475/* */ 19476 19477/** 19478 * Expand input[v-model] with dyanmic type bindings into v-if-else chains 19479 * Turn this: 19480 * <input v-model="data[type]" :type="type"> 19481 * into this: 19482 * <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]"> 19483 * <input v-else-if="type === 'radio'" type="radio" v-model="data[type]"> 19484 * <input v-else :type="type" v-model="data[type]"> 19485 */ 19486 19487function preTransformNode (el, options) { 19488 if (el.tag === 'input') { 19489 var map = el.attrsMap; 19490 if (map['v-model'] && (map['v-bind:type'] || map[':type'])) { 19491 var typeBinding = getBindingAttr(el, 'type'); 19492 var ifCondition = getAndRemoveAttr(el, 'v-if', true); 19493 var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : ""; 19494 var hasElse = getAndRemoveAttr(el, 'v-else', true) != null; 19495 var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); 19496 // 1. checkbox 19497 var branch0 = cloneASTElement(el); 19498 // process for on the main node 19499 processFor(branch0); 19500 addRawAttr(branch0, 'type', 'checkbox'); 19501 processElement(branch0, options); 19502 branch0.processed = true; // prevent it from double-processed 19503 branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra; 19504 addIfCondition(branch0, { 19505 exp: branch0.if, 19506 block: branch0 19507 }); 19508 // 2. add radio else-if condition 19509 var branch1 = cloneASTElement(el); 19510 getAndRemoveAttr(branch1, 'v-for', true); 19511 addRawAttr(branch1, 'type', 'radio'); 19512 processElement(branch1, options); 19513 addIfCondition(branch0, { 19514 exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra, 19515 block: branch1 19516 }); 19517 // 3. other 19518 var branch2 = cloneASTElement(el); 19519 getAndRemoveAttr(branch2, 'v-for', true); 19520 addRawAttr(branch2, ':type', typeBinding); 19521 processElement(branch2, options); 19522 addIfCondition(branch0, { 19523 exp: ifCondition, 19524 block: branch2 19525 }); 19526 19527 if (hasElse) { 19528 branch0.else = true; 19529 } else if (elseIfCondition) { 19530 branch0.elseif = elseIfCondition; 19531 } 19532 19533 return branch0 19534 } 19535 } 19536} 19537 19538function cloneASTElement (el) { 19539 return createASTElement(el.tag, el.attrsList.slice(), el.parent) 19540} 19541 19542function addRawAttr (el, name, value) { 19543 el.attrsMap[name] = value; 19544 el.attrsList.push({ name: name, value: value }); 19545} 19546 19547var model$2 = { 19548 preTransformNode: preTransformNode 19549}; 19550 19551var modules$1 = [ 19552 klass$1, 19553 style$1, 19554 model$2 19555]; 19556 19557/* */ 19558 19559function text (el, dir) { 19560 if (dir.value) { 19561 addProp(el, 'textContent', ("_s(" + (dir.value) + ")")); 19562 } 19563} 19564 19565/* */ 19566 19567function html (el, dir) { 19568 if (dir.value) { 19569 addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")")); 19570 } 19571} 19572 19573var directives$1 = { 19574 model: model, 19575 text: text, 19576 html: html 19577}; 19578 19579/* */ 19580 19581var baseOptions = { 19582 expectHTML: true, 19583 modules: modules$1, 19584 directives: directives$1, 19585 isPreTag: isPreTag, 19586 isUnaryTag: isUnaryTag, 19587 mustUseProp: mustUseProp, 19588 canBeLeftOpenTag: canBeLeftOpenTag, 19589 isReservedTag: isReservedTag, 19590 getTagNamespace: getTagNamespace, 19591 staticKeys: genStaticKeys(modules$1) 19592}; 19593 19594/* */ 19595 19596var isStaticKey; 19597var isPlatformReservedTag; 19598
19599var genStaticKeysCached = cached(genStaticKeys$1); 19600 19601/** 19602 * Goal of the optimizer: walk the generated template AST tree 19603 * and detect sub-trees that are purely static, i.e. parts of 19604 * the DOM that never needs to change. 19605 * 19606 * Once we detect these sub-trees, we can: 19607 * 19608 * 1. Hoist them into constants, so that we no longer need to 19609 * create fresh nodes for them on each re-render; 19610 * 2. Completely skip them in the patching process. 19611 */ 19612function optimize (root, options) { 19613 if (!root) { return } 19614 isStaticKey = genStaticKeysCached(options.staticKeys || ''); 19615 isPlatformReservedTag = options.isReservedTag || no; 19616 // first pass: mark all non-static nodes. 19617 markStatic$1(root); 19618 // second pass: mark static roots. 19619 markStaticRoots(root, false); 19620} 19621 19622function genStaticKeys$1 (keys) { 19623 return makeMap( 19624 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' + 19625 (keys ? ',' + keys : '') 19626 ) 19627} 19628 19629function markStatic$1 (node) { 19630 node.static = isStatic(node); 19631 if (node.type === 1) { 19632 // do not make component slot content static. this avoids 19633 // 1. components not able to mutate slot nodes 19634 // 2. static slot content fails for hot-reloading 19635 if ( 19636 !isPlatformReservedTag(node.tag) && 19637 node.tag !== 'slot' && 19638 node.attrsMap['inline-template'] == null 19639 ) { 19640 return 19641 } 19642 for (var i = 0, l = node.children.length; i < l; i++) { 19643 var child = node.children[i]; 19644 markStatic$1(child); 19645 if (!child.static) { 19646 node.static = false; 19647 } 19648 } 19649 if (node.ifConditions) { 19650 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 19651 var block = node.ifConditions[i$1].block; 19652 markStatic$1(block); 19653 if (!block.static) { 19654 node.static = false; 19655 } 19656 } 19657 } 19658 } 19659} 19660 19661function markStaticRoots (node, isInFor) { 19662 if (node.type === 1) { 19663 if (node.static || node.once) { 19664 node.staticInFor = isInFor; 19665 } 19666 // For a node to qualify as a static root, it should have children that 19667 // are not just static text. Otherwise the cost of hoisting out will 19668 // outweigh the benefits and it's better off to just always render it fresh. 19669 if (node.static && node.children.length && !( 19670 node.children.length === 1 && 19671 node.children[0].type === 3 19672 )) { 19673 node.staticRoot = true; 19674 return 19675 } else { 19676 node.staticRoot = false; 19677 } 19678 if (node.children) { 19679 for (var i = 0, l = node.children.length; i < l; i++) { 19680 markStaticRoots(node.children[i], isInFor || !!node.for); 19681 } 19682 } 19683 if (node.ifConditions) { 19684 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 19685 markStaticRoots(node.ifConditions[i$1].block, isInFor); 19686 } 19687 } 19688 } 19689} 19690 19691function isStatic (node) { 19692 if (node.type === 2) { // expression 19693 return false 19694 } 19695 if (node.type === 3) { // text 19696 return true 19697 } 19698 return !!(node.pre || ( 19699 !node.hasBindings && // no dynamic bindings 19700 !node.if && !node.for && // not v-if or v-for or v-else 19701 !isBuiltInTag(node.tag) && // not a built-in 19702 isPlatformReservedTag(node.tag) && // not a component 19703 !isDirectChildOfTemplateFor(node) && 19704 Object.keys(node).every(isStaticKey) 19705 )) 19706} 19707 19708function isDirectChildOfTemplateFor (node) { 19709 while (node.parent) { 19710 node = node.parent; 19711 if (node.tag !== 'template') { 19712 return false 19713 } 19714 if (node.for) { 19715 return true 19716 } 19717 } 19718 return false 19719} 19720 19721/* */ 19722 19723var fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/; 19724var simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?']|\[".*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*\s*$/; 19725 19726// keyCode aliases 19727var keyCodes = { 19728 esc: 27, 19729 tab: 9, 19730 enter: 13, 19731 space: 32, 19732 up: 38, 19733 left: 37, 19734 right: 39, 19735 down: 40, 19736 'delete': [8, 46] 19737}; 19738 19739// #4868: modifiers that prevent the execution of the listener 19740// need to explicitly return null so that we can determine whether to remove 19741// the listener for .once 19742var genGuard = function (condition) { return ("if(" + condition + ")return null;"); }; 19743 19744var modifierCode = { 19745 stop: '$event.stopPropagation();', 19746 prevent: '$event.preventDefault();', 19747 self: genGuard("$event.target !== $event.currentTarget"), 19748 ctrl: genGuard("!$event.ctrlKey"), 19749 shift: genGuard("!$event.shiftKey"), 19750 alt: genGuard("!$event.altKey"), 19751 meta: genGuard("!$event.metaKey"), 19752 left: genGuard("'button' in $event && $event.button !== 0"), 19753 middle: genGuard("'button' in $event && $event.button !== 1"), 19754 right: genGuard("'button' in $event && $event.button !== 2") 19755}; 19756 19757function genHandlers ( 19758 events, 19759 isNative, 19760 warn 19761) { 19762 var res = isNative ? 'nativeOn:{' : 'on:{'; 19763 for (var name in events) { 19764 res += "\"" + name + "\":" + (genHandler(name, events[name])) + ","; 19765 } 19766 return res.slice(0, -1) + '}' 19767} 19768 19769function genHandler ( 19770 name, 19771 handler 19772) { 19773 if (!handler) { 19774 return 'function(){}' 19775 } 19776 19777 if (Array.isArray(handler)) { 19778 return ("[" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + "]") 19779 } 19780 19781 var isMethodPath = simplePathRE.test(handler.value); 19782 var isFunctionExpression = fnExpRE.test(handler.value); 19783 19784 if (!handler.modifiers) { 19785 return isMethodPath || isFunctionExpression 19786 ? handler.value 19787 : ("function($event){" + (handler.value) + "}") // inline statement 19788 } else { 19789 var code = ''; 19790 var genModifierCode = ''; 19791 var keys = []; 19792 for (var key in handler.modifiers) { 19793 if (modifierCode[key]) { 19794 genModifierCode += modifierCode[key]; 19795 // left/right 19796 if (keyCodes[key]) { 19797 keys.push(key); 19798 } 19799 } else if (key === 'exact') { 19800 var modifiers = (handler.modifiers); 19801 genModifierCode += genGuard( 19802 ['ctrl', 'shift', 'alt', 'meta'] 19803 .filter(function (keyModifier) { return !modifiers[keyModifier]; }) 19804 .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); }) 19805 .join('||') 19806 ); 19807 } else { 19808 keys.push(key); 19809 } 19810 } 19811 if (keys.length) { 19812 code += genKeyFilter(keys); 19813 } 19814 // Make sure modifiers like prevent and stop get executed after key filtering 19815 if (genModifierCode) { 19816 code += genModifierCode; 19817 } 19818 var handlerCode = isMethodPath 19819 ? handler.value + '($event)' 19820 : isFunctionExpression 19821 ? ("(" + (handler.value) + ")($event)") 19822 : handler.value; 19823 return ("function($event){" + code + handlerCode + "}") 19824 } 19825} 19826 19827function genKeyFilter (keys) { 19828 return ("if(!('button' in $event)&&" + (keys.map(genFilterCode).join('&&')) + ")return null;") 19829} 19830 19831function genFilterCode (key) { 19832 var keyVal = parseInt(key, 10); 19833 if (keyVal) { 19834 return ("$event.keyCode!==" + keyVal) 19835 } 19836 var code = keyCodes[key]; 19837 return ( 19838 "_k($event.keyCode," + 19839 (JSON.stringify(key)) + "," + 19840 (JSON.stringify(code)) + "," + 19841 "$event.key)" 19842 ) 19843} 19844 19845/* */ 19846 19847function on (el, dir) { 19848 if (process.env.NODE_ENV !== 'production' && dir.modifiers) { 19849 warn("v-on without argument does not support modifiers."); 19850 } 19851 el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); }; 19852} 19853 19854/* */ 19855 19856function bind$1 (el, dir) { 19857 el.wrapData = function (code) { 19858 return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")") 19859 }; 19860} 19861 19862/* */ 19863 19864var baseDirectives = { 19865 on: on, 19866 bind: bind$1, 19867 cloak: noop 19868}; 19869 19870/* */ 19871 19872var CodegenState = function CodegenState (options) { 19873 this.options = options; 19874 this.warn = options.warn || baseWarn; 19875 this.transforms = pluckModuleFunction(options.modules, 'transformCode'); 19876 this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); 19877 this.directives = extend(extend({}, baseDirectives), options.directives); 19878 var isReservedTag = options.isReservedTag || no; 19879 this.maybeComponent = function (el) { return !isReservedTag(el.tag); }; 19880 this.onceId = 0; 19881 this.staticRenderFns = []; 19882}; 19883 19884 19885 19886function generate ( 19887 ast, 19888 options 19889) { 19890 var state = new CodegenState(options); 19891 var code = ast ? genElement(ast, state) : '_c("div")'; 19892 return { 19893 render: ("with(this){return " + code + "}"), 19894 staticRenderFns: state.staticRenderFns 19895 } 19896} 19897 19898function genElement (el, state) { 19899 if (el.staticRoot && !el.staticProcessed) { 19900 return genStatic(el, state) 19901 } else if (el.once && !el.onceProcessed) { 19902 return genOnce(el, state) 19903 } else if (el.for && !el.forProcessed) { 19904 return genFor(el, state) 19905 } else if (el.if && !el.ifProcessed) { 19906 return genIf(el, state) 19907 } else if (el.tag === 'template' && !el.slotTarget) { 19908 return genChildren(el, state) || 'void 0' 19909 } else if (el.tag === 'slot') { 19910 return genSlot(el, state) 19911 } else { 19912 // component or element 19913 var code; 19914 if (el.component) { 19915 code = genComponent(el.component, el, state); 19916 } else { 19917 var data = el.plain ? undefined : genData$2(el, state); 19918 19919 var children = el.inlineTemplate ? null : genChildren(el, state, true);
19920 code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")"; 19921 } 19922 // module transforms 19923 for (var i = 0; i < state.transforms.length; i++) { 19924 code = state.transforms[i](el, code); 19925 } 19926 return code 19927 } 19928} 19929 19930// hoist static sub-trees out 19931function genStatic (el, state, once$$1) { 19932 el.staticProcessed = true; 19933 state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}")); 19934 return ("_m(" + (state.staticRenderFns.length - 1) + "," + (el.staticInFor ? 'true' : 'false') + "," + (once$$1 ? 'true' : 'false') + ")") 19935} 19936 19937// v-once 19938function genOnce (el, state) { 19939 el.onceProcessed = true; 19940 if (el.if && !el.ifProcessed) { 19941 return genIf(el, state) 19942 } else if (el.staticInFor) { 19943 var key = ''; 19944 var parent = el.parent; 19945 while (parent) { 19946 if (parent.for) { 19947 key = parent.key; 19948 break 19949 } 19950 parent = parent.parent; 19951 } 19952 if (!key) { 19953 process.env.NODE_ENV !== 'production' && state.warn( 19954 "v-once can only be used inside v-for that is keyed. " 19955 ); 19956 return genElement(el, state) 19957 } 19958 return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")") 19959 } else { 19960 return genStatic(el, state, true) 19961 } 19962} 19963 19964function genIf ( 19965 el, 19966 state, 19967 altGen, 19968 altEmpty 19969) { 19970 el.ifProcessed = true; // avoid recursion 19971 return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty) 19972} 19973 19974function genIfConditions ( 19975 conditions, 19976 state, 19977 altGen, 19978 altEmpty 19979) { 19980 if (!conditions.length) { 19981 return altEmpty || '_e()' 19982 } 19983 19984 var condition = conditions.shift(); 19985 if (condition.exp) { 19986 return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty))) 19987 } else { 19988 return ("" + (genTernaryExp(condition.block))) 19989 } 19990 19991 // v-if with v-once should generate code like (a)?_m(0):_m(1) 19992 function genTernaryExp (el) { 19993 return altGen 19994 ? altGen(el, state) 19995 : el.once 19996 ? genOnce(el, state) 19997 : genElement(el, state) 19998 } 19999} 20000 20001function genFor ( 20002 el, 20003 state, 20004 altGen, 20005 altHelper 20006) { 20007 var exp = el.for; 20008 var alias = el.alias; 20009 var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; 20010 var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; 20011 20012 if (process.env.NODE_ENV !== 'production' && 20013 state.maybeComponent(el) && 20014 el.tag !== 'slot' && 20015 el.tag !== 'template' && 20016 !el.key 20017 ) { 20018 state.warn( 20019 "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " + 20020 "v-for should have explicit keys. " + 20021 "See https://vuejs.org/guide/list.html#key for more info.", 20022 true /* tip */ 20023 ); 20024 } 20025 20026 el.forProcessed = true; // avoid recursion 20027 return (altHelper || '_l') + "((" + exp + ")," + 20028 "function(" + alias + iterator1 + iterator2 + "){" + 20029 "return " + ((altGen || genElement)(el, state)) + 20030 '})' 20031} 20032 20033function genData$2 (el, state) { 20034 var data = '{'; 20035 20036 // directives first. 20037 // directives may mutate the el's other properties before they are generated. 20038 var dirs = genDirectives(el, state); 20039 if (dirs) { data += dirs + ','; } 20040 20041 // key 20042 if (el.key) { 20043 data += "key:" + (el.key) + ","; 20044 } 20045 // ref 20046 if (el.ref) { 20047 data += "ref:" + (el.ref) + ","; 20048 } 20049 if (el.refInFor) { 20050 data += "refInFor:true,"; 20051 } 20052 // pre 20053 if (el.pre) { 20054 data += "pre:true,"; 20055 } 20056 // record original tag name for components using "is" attribute 20057 if (el.component) { 20058 data += "tag:\"" + (el.tag) + "\","; 20059 } 20060 // module data generation functions 20061 for (var i = 0; i < state.dataGenFns.length; i++) { 20062 data += state.dataGenFns[i](el); 20063 } 20064 // attributes 20065 if (el.attrs) { 20066 data += "attrs:{" + (genProps(el.attrs)) + "},"; 20067 } 20068 // DOM props 20069 if (el.props) { 20070 data += "domProps:{" + (genProps(el.props)) + "},"; 20071 } 20072 // event handlers 20073 if (el.events) { 20074 data += (genHandlers(el.events, false, state.warn)) + ","; 20075 } 20076 if (el.nativeEvents) { 20077 data += (genHandlers(el.nativeEvents, true, state.warn)) + ","; 20078 } 20079 // slot target 20080 // only for non-scoped slots 20081 if (el.slotTarget && !el.slotScope) { 20082 data += "slot:" + (el.slotTarget) + ","; 20083 } 20084 // scoped slots 20085 if (el.scopedSlots) { 20086 data += (genScopedSlots(el.scopedSlots, state)) + ","; 20087 } 20088 // component v-model 20089 if (el.model) { 20090 data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},"; 20091 } 20092 // inline-template 20093 if (el.inlineTemplate) { 20094 var inlineTemplate = genInlineTemplate(el, state); 20095 if (inlineTemplate) { 20096 data += inlineTemplate + ","; 20097 } 20098 } 20099 data = data.replace(/,$/, '') + '}'; 20100 // v-bind data wrap 20101 if (el.wrapData) { 20102 data = el.wrapData(data); 20103 } 20104 // v-on data wrap 20105 if (el.wrapListeners) { 20106 data = el.wrapListeners(data); 20107 } 20108 return data 20109} 20110 20111function genDirectives (el, state) { 20112 var dirs = el.directives; 20113 if (!dirs) { return } 20114 var res = 'directives:['; 20115 var hasRuntime = false;
20116 var i, l, dir, needRuntime; 20117 for (i = 0, l = dirs.length; i < l; i++) { 20118 dir = dirs[i]; 20119 needRuntime = true; 20120 var gen = state.directives[dir.name]; 20121 if (gen) { 20122 // compile-time directive that manipulates AST. 20123 // returns true if it also needs a runtime counterpart. 20124 needRuntime = !!gen(el, dir, state.warn); 20125 } 20126 if (needRuntime) { 20127 hasRuntime = true; 20128 res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:\"" + (dir.arg) + "\"") : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},"; 20129 } 20130 } 20131 if (hasRuntime) { 20132 return res.slice(0, -1) + ']' 20133 } 20134} 20135 20136function genInlineTemplate (el, state) { 20137 var ast = el.children[0]; 20138 if (process.env.NODE_ENV !== 'production' && ( 20139 el.children.length !== 1 || ast.type !== 1 20140 )) { 20141 state.warn('Inline-template components must have exactly one child element.'); 20142 } 20143 if (ast.type === 1) { 20144 var inlineRenderFns = generate(ast, state.options); 20145 return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}") 20146 } 20147} 20148 20149function genScopedSlots ( 20150 slots, 20151 state 20152) { 20153 return ("scopedSlots:_u([" + (Object.keys(slots).map(function (key) { 20154 return genScopedSlot(key, slots[key], state) 20155 }).join(',')) + "])") 20156} 20157 20158function genScopedSlot ( 20159 key, 20160 el, 20161 state 20162) { 20163 if (el.for && !el.forProcessed) { 20164 return genForScopedSlot(key, el, state) 20165 } 20166 var fn = "function(" + (String(el.slotScope)) + "){" + 20167 "return " + (el.tag === 'template' 20168 ? el.if 20169 ? ((el.if) + "?" + (genChildren(el, state) || 'undefined') + ":undefined") 20170 : genChildren(el, state) || 'undefined' 20171 : genElement(el, state)) + "}"; 20172 return ("{key:" + key + ",fn:" + fn + "}") 20173} 20174 20175function genForScopedSlot ( 20176 key, 20177 el, 20178 state 20179) { 20180 var exp = el.for; 20181 var alias = el.alias; 20182 var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; 20183 var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; 20184 el.forProcessed = true; // avoid recursion 20185 return "_l((" + exp + ")," + 20186 "function(" + alias + iterator1 + iterator2 + "){" + 20187 "return " + (genScopedSlot(key, el, state)) + 20188 '})' 20189} 20190 20191function genChildren ( 20192 el, 20193 state, 20194 checkSkip, 20195 altGenElement, 20196 altGenNode 20197) { 20198 var children = el.children; 20199 if (children.length) { 20200 var el$1 = children[0]; 20201 // optimize single v-for 20202 if (children.length === 1 && 20203 el$1.for && 20204 el$1.tag !== 'template' && 20205 el$1.tag !== 'slot' 20206 ) { 20207 return (altGenElement || genElement)(el$1, state) 20208 } 20209 var normalizationType = checkSkip 20210 ? getNormalizationType(children, state.maybeComponent) 20211 : 0; 20212 var gen = altGenNode || genNode; 20213 return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType ? ("," + normalizationType) : '')) 20214 } 20215} 20216 20217// determine the normalization needed for the children array. 20218// 0: no normalization needed 20219// 1: simple normalization needed (possible 1-level deep nested array) 20220// 2: full normalization needed 20221function getNormalizationType ( 20222 children, 20223 maybeComponent 20224) { 20225 var res = 0; 20226 for (var i = 0; i < children.length; i++) { 20227 var el = children[i]; 20228 if (el.type !== 1) { 20229 continue 20230 } 20231 if (needsNormalization(el) || 20232 (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) { 20233 res = 2; 20234 break 20235 } 20236 if (maybeComponent(el) || 20237 (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) { 20238 res = 1; 20239 } 20240 } 20241 return res 20242} 20243 20244function needsNormalization (el) { 20245 return el.for !== undefined || el.tag === 'template' || el.tag === 'slot' 20246} 20247 20248function genNode (node, state) { 20249 if (node.type === 1) { 20250 return genElement(node, state) 20251 } if (node.type === 3 && node.isComment) { 20252 return genComment(node) 20253 } else { 20254 return genText(node) 20255 } 20256} 20257 20258function genText (text) { 20259 return ("_v(" + (text.type === 2 20260 ? text.expression // no need for () because already wrapped in _s() 20261 : transformSpecialNewlines(JSON.stringify(text.text))) + ")") 20262} 20263 20264function genComment (comment) { 20265 return ("_e(" + (JSON.stringify(comment.text)) + ")") 20266} 20267 20268function genSlot (el, state) { 20269 var slotName = el.slotName || '"default"'; 20270 var children = genChildren(el, state); 20271 var res = "_t(" + slotName + (children ? ("," + children) : ''); 20272 var attrs = el.attrs && ("{" + (el.attrs.map(function (a) { return ((camelize(a.name)) + ":" + (a.value)); }).join(',')) + "}"); 20273 var bind$$1 = el.attrsMap['v-bind']; 20274 if ((attrs || bind$$1) && !children) { 20275 res += ",null"; 20276 } 20277 if (attrs) { 20278 res += "," + attrs; 20279 } 20280 if (bind$$1) { 20281 res += (attrs ? '' : ',null') + "," + bind$$1; 20282 } 20283 return res + ')' 20284} 20285 20286// componentName is el.component, take it as argument to shun flow's pessimistic refinement 20287function genComponent ( 20288 componentName, 20289 el, 20290 state 20291) { 20292 var children = el.inlineTemplate ? null : genChildren(el, state, true); 20293 return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")") 20294} 20295 20296function genProps (props) { 20297 var res = ''; 20298 for (var i = 0; i < props.length; i++) { 20299 var prop = props[i]; 20300 res += "\"" + (prop.name) + "\":" + (transformSpecialNewlines(prop.value)) + ","; 20301 } 20302 return res.slice(0, -1) 20303} 20304 20305// #3895, #4268 20306function transformSpecialNewlines (text) { 20307 return text 20308 .replace(/\u2028/g, '\\u2028') 20309 .replace(/\u2029/g, '\\u2029') 20310} 20311 20312/* */ 20313 20314// these keywords should not appear inside expressions, but operators like 20315// typeof, instanceof and in are allowed 20316var prohibitedKeywordRE = new RegExp('\\b' + ( 20317 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 20318 'super,throw,while,yield,delete,export,import,return,switch,default,' + 20319 'extends,finally,continue,debugger,function,arguments' 20320).split(',').join('\\b|\\b') + '\\b'); 20321 20322// these unary operators should not be used as property/method names 20323var unaryOperatorsRE = new RegExp('\\b' + ( 20324 'delete,typeof,void' 20325).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)'); 20326 20327// strip strings in expressions 20328var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 20329 20330// detect problematic expressions in a template 20331function detectErrors (ast) { 20332 var errors = []; 20333 if (ast) { 20334 checkNode(ast, errors); 20335 } 20336 return errors 20337} 20338 20339function checkNode (node, errors) { 20340 if (node.type === 1) { 20341 for (var name in node.attrsMap) { 20342 if (dirRE.test(name)) { 20343 var value = node.attrsMap[name]; 20344 if (value) { 20345 if (name === 'v-for') { 20346 checkFor(node, ("v-for=\"" + value + "\""), errors); 20347 } else if (onRE.test(name)) { 20348 checkEvent(value, (name + "=\"" + value + "\""), errors); 20349 } else { 20350 checkExpression(value, (name + "=\"" + value + "\""), errors); 20351 } 20352 } 20353 } 20354 } 20355 if (node.children) { 20356 for (var i = 0; i < node.children.length; i++) { 20357 checkNode(node.children[i], errors); 20358 } 20359 } 20360 } else if (node.type === 2) { 20361 checkExpression(node.expression, node.text, errors); 20362 } 20363} 20364 20365function checkEvent (exp, text, errors) { 20366 var stipped = exp.replace(stripStringRE, ''); 20367 var keywordMatch = stipped.match(unaryOperatorsRE); 20368 if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') { 20369 errors.push( 20370 "avoid using JavaScript unary operator as property name: " + 20371 "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()) 20372 ); 20373 } 20374 checkExpression(exp, text, errors); 20375} 20376 20377function checkFor (node, text, errors) { 20378 checkExpression(node.for || '', text, errors); 20379 checkIdentifier(node.alias, 'v-for alias', text, errors); 20380 checkIdentifier(node.iterator1, 'v-for iterator', text, errors); 20381 checkIdentifier(node.iterator2, 'v-for iterator', text, errors); 20382} 20383 20384function checkIdentifier ( 20385 ident, 20386 type, 20387 text, 20388 errors 20389) { 20390 if (typeof ident === 'string') { 20391 try { 20392 new Function(("var " + ident + "=_")); 20393 } catch (e) { 20394 errors.push(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim()))); 20395 } 20396 } 20397} 20398 20399function checkExpression (exp, text, errors) { 20400 try { 20401 new Function(("return " + exp)); 20402 } catch (e) { 20403 var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE); 20404 if (keywordMatch) { 20405 errors.push( 20406 "avoid using JavaScript keyword as property name: " + 20407 "\"" + (keywordMatch[0]) + "\"\n Raw expression: " + (text.trim()) 20408 ); 20409 } else { 20410 errors.push( 20411 "invalid expression: " + (e.message) + " in\n\n" + 20412 " " + exp + "\n\n" + 20413 " Raw expression: " + (text.trim()) + "\n" 20414 ); 20415 } 20416 } 20417} 20418 20419/* */ 20420 20421function createFunction (code, errors) { 20422 try { 20423 return new Function(code) 20424 } catch (err) { 20425 errors.push({ err: err, code: code }); 20426 return noop 20427 } 20428} 20429 20430function createCompileToFunctionFn (compile) { 20431 var cache = Object.create(null); 20432 20433 return function compileToFunctions ( 20434 template, 20435 options, 20436 vm 20437 ) { 20438 options = extend({}, options); 20439 var warn$$1 = options.warn || warn; 20440 delete options.warn; 20441 20442 /* istanbul ignore if */ 20443 if (process.env.NODE_ENV !== 'production') { 20444 // detect possible CSP restriction
20445 try { 20446 new Function('return 1'); 20447 } catch (e) { 20448 if (e.toString().match(/unsafe-eval|CSP/)) { 20449 warn$$1( 20450 'It seems you are using the standalone build of Vue.js in an ' + 20451 'environment with Content Security Policy that prohibits unsafe-eval. ' + 20452 'The template compiler cannot work in this environment. Consider ' + 20453 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + 20454 'templates into render functions.' 20455 ); 20456 } 20457 } 20458 } 20459 20460 // check cache 20461 var key = options.delimiters 20462 ? String(options.delimiters) + template 20463 : template; 20464 if (cache[key]) { 20465 return cache[key] 20466 } 20467 20468 // compile 20469 var compiled = compile(template, options); 20470 20471 // check compilation errors/tips 20472 if (process.env.NODE_ENV !== 'production') { 20473 if (compiled.errors && compiled.errors.length) { 20474 warn$$1( 20475 "Error compiling template:\n\n" + template + "\n\n" + 20476 compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n', 20477 vm 20478 ); 20479 } 20480 if (compiled.tips && compiled.tips.length) { 20481 compiled.tips.forEach(function (msg) { return tip(msg, vm); }); 20482 } 20483 } 20484 20485 // turn code into functions 20486 var res = {}; 20487 var fnGenErrors = []; 20488 res.render = createFunction(compiled.render, fnGenErrors); 20489 res.staticRenderFns = compiled.staticRenderFns.map(function (code) { 20490 return createFunction(code, fnGenErrors) 20491 }); 20492 20493 // check function generation errors. 20494 // this should only happen if there is a bug in the compiler itself. 20495 // mostly for codegen development use 20496 /* istanbul ignore if */ 20497 if (process.env.NODE_ENV !== 'production') { 20498 if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) { 20499 warn$$1( 20500 "Failed to generate render function:\n\n" + 20501 fnGenErrors.map(function (ref) { 20502 var err = ref.err; 20503 var code = ref.code; 20504 20505 return ((err.toString()) + " in\n\n" + code + "\n"); 20506 }).join('\n'), 20507 vm 20508 ); 20509 } 20510 } 20511 20512 return (cache[key] = res) 20513 } 20514} 20515 20516/* */ 20517 20518function createCompilerCreator (baseCompile) { 20519 return function createCompiler (baseOptions) { 20520 function compile ( 20521 template, 20522 options 20523 ) { 20524 var finalOptions = Object.create(baseOptions); 20525 var errors = []; 20526 var tips = []; 20527 finalOptions.warn = function (msg, tip) { 20528 (tip ? tips : errors).push(msg); 20529 }; 20530 20531 if (options) { 20532 // merge custom modules 20533 if (options.modules) { 20534 finalOptions.modules = 20535 (baseOptions.modules || []).concat(options.modules); 20536 } 20537 // merge custom directives 20538 if (options.directives) { 20539 finalOptions.directives = extend( 20540 Object.create(baseOptions.directives), 20541 options.directives 20542 ); 20543 } 20544 // copy other options 20545 for (var key in options) { 20546 if (key !== 'modules' && key !== 'directives') { 20547 finalOptions[key] = options[key]; 20548 } 20549 } 20550 } 20551 20552 var compiled = baseCompile(template, finalOptions); 20553 if (process.env.NODE_ENV !== 'production') { 20554 errors.push.apply(errors, detectErrors(compiled.ast)); 20555 } 20556 compiled.errors = errors; 20557 compiled.tips = tips; 20558 return compiled 20559 } 20560 20561 return { 20562 compile: compile, 20563 compileToFunctions: createCompileToFunctionFn(compile) 20564 } 20565 } 20566} 20567 20568/* */ 20569 20570// `createCompilerCreator` allows creating compilers that use alternative 20571// parser/optimizer/codegen, e.g the SSR optimizing compiler. 20572// Here we just export a default compiler using the default parts. 20573var createCompiler = createCompilerCreator(function baseCompile ( 20574 template, 20575 options 20576) { 20577 var ast = parse(template.trim(), options); 20578 optimize(ast, options); 20579 var code = generate(ast, options); 20580 return { 20581 ast: ast, 20582 render: code.render, 20583 staticRenderFns: code.staticRenderFns 20584 } 20585}); 20586 20587/* */ 20588 20589var ref$1 = createCompiler(baseOptions); 20590var compileToFunctions = ref$1.compileToFunctions; 20591 20592/* */ 20593 20594// check whether current browser encodes a char inside attribute values 20595var div; 20596function getShouldDecode (href) { 20597 div = div || document.createElement('div'); 20598 div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>"; 20599 return div.innerHTML.indexOf(' ') > 0 20600} 20601 20602// #3663: IE encodes newlines inside attribute values while other browsers don't 20603var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
20604// #6828: chrome encodes content in a[href] 20605var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false; 20606 20607/* */ 20608 20609var idToTemplate = cached(function (id) { 20610 var el = query(id); 20611 return el && el.innerHTML 20612}); 20613 20614var mount = Vue$3.prototype.$mount; 20615Vue$3.prototype.$mount = function ( 20616 el, 20617 hydrating 20618) { 20619 el = el && query(el); 20620 20621 /* istanbul ignore if */ 20622 if (el === document.body || el === document.documentElement) { 20623 process.env.NODE_ENV !== 'production' && warn( 20624 "Do not mount Vue to <html> or <body> - mount to normal elements instead." 20625 ); 20626 return this 20627 } 20628 20629 var options = this.$options; 20630 // resolve template/el and convert to render function 20631 if (!options.render) { 20632 var template = options.template; 20633 if (template) { 20634 if (typeof template === 'string') { 20635 if (template.charAt(0) === '#') { 20636 template = idToTemplate(template); 20637 /* istanbul ignore if */ 20638 if (process.env.NODE_ENV !== 'production' && !template) { 20639 warn( 20640 ("Template element not found or is empty: " + (options.template)), 20641 this 20642 ); 20643 } 20644 } 20645 } else if (template.nodeType) { 20646 template = template.innerHTML; 20647 } else { 20648 if (process.env.NODE_ENV !== 'production') { 20649 warn('invalid template option:' + template, this); 20650 } 20651 return this 20652 } 20653 } else if (el) { 20654 template = getOuterHTML(el); 20655 } 20656 if (template) { 20657 /* istanbul ignore if */ 20658 if (process.env.NODE_ENV !== 'production' && config.performance && mark) { 20659 mark('compile'); 20660 } 20661 20662 var ref = compileToFunctions(template, { 20663 shouldDecodeNewlines: shouldDecodeNewlines, 20664 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, 20665 delimiters: options.delimiters, 20666 comments: options.comments 20667 }, this); 20668 var render = ref.render; 20669 var staticRenderFns = ref.staticRenderFns; 20670 options.render = render; 20671 options.staticRenderFns = staticRenderFns; 20672 20673 /* istanbul ignore if */ 20674 if (process.env.NODE_ENV !== 'production' && config.performance && mark) { 20675 mark('compile end'); 20676 measure(("vue " + (this._name) + " compile"), 'compile', 'compile end'); 20677 } 20678 } 20679 } 20680 return mount.call(this, el, hydrating) 20681}; 20682 20683/** 20684 * Get outerHTML of elements, taking care 20685 * of SVG elements in IE as well. 20686 */ 20687function getOuterHTML (el) { 20688 if (el.outerHTML) { 20689 return el.outerHTML 20690 } else { 20691 var container = document.createElement('div'); 20692 container.appendChild(el.cloneNode(true)); 20693 return container.innerHTML 20694 } 20695} 20696 20697Vue$3.compile = compileToFunctions; 20698 20699module.exports = Vue$3; 20700 20701/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1), __webpack_require__(0), __webpack_require__(2).setImmediate)) 20702 20703/***/ }), 20704/* 37 */ 20705/***/ (function(module, exports, __webpack_require__) { 20706 20707/* WEBPACK VAR INJECTION */(function(global, setImmediate) {/*! 20708 * Vue.js v2.5.8 20709 * (c) 2014-2017 Evan You 20710 * Released under the MIT License. 20711 */ 20712(function (global, factory) { 20713 true ? module.exports = factory() : 20714 typeof define === 'function' && define.amd ? define(factory) : 20715 (global.Vue = factory()); 20716}(this, (function () { 'use strict'; 20717 20718/* */ 20719 20720var emptyObject = Object.freeze({}); 20721 20722// these helpers produces better vm code in JS engines due to their 20723// explicitness and function inlining 20724function isUndef (v) { 20725 return v === undefined || v === null 20726} 20727 20728function isDef (v) { 20729 return v !== undefined && v !== null 20730} 20731 20732function isTrue (v) { 20733 return v === true 20734} 20735 20736function isFalse (v) { 20737 return v === false 20738} 20739 20740/** 20741 * Check if value is primitive 20742 */ 20743function isPrimitive (value) { 20744 return ( 20745 typeof value === 'string' || 20746 typeof value === 'number' || 20747 typeof value === 'boolean' 20748 ) 20749} 20750 20751/** 20752 * Quick object check - this is primarily used to tell 20753 * Objects from primitive values when we know the value 20754 * is a JSON-compliant type. 20755 */ 20756function isObject (obj) { 20757 return obj !== null && typeof obj === 'object' 20758} 20759 20760/** 20761 * Get the raw type string of a value e.g. [object Object] 20762 */ 20763var _toString = Object.prototype.toString; 20764 20765function toRawType (value) { 20766 return _toString.call(value).slice(8, -1) 20767} 20768 20769/** 20770 * Strict object type check. Only returns true 20771 * for plain JavaScript objects. 20772 */ 20773function isPlainObject (obj) { 20774 return _toString.call(obj) === '[object Object]' 20775} 20776 20777function isRegExp (v) { 20778 return _toString.call(v) === '[object RegExp]' 20779} 20780 20781/** 20782 * Check if val is a valid array index. 20783 */ 20784function isValidArrayIndex (val) { 20785 var n = parseFloat(String(val)); 20786 return n >= 0 && Math.floor(n) === n && isFinite(val) 20787} 20788 20789/** 20790 * Convert a value to a string that is actually rendered. 20791 */ 20792function toString (val) { 20793 return val == null 20794 ? '' 20795 : typeof val === 'object' 20796 ? JSON.stringify(val, null, 2) 20797 : String(val) 20798} 20799 20800/** 20801 * Convert a input value to a number for persistence. 20802 * If the conversion fails, return original string. 20803 */ 20804function toNumber (val) { 20805 var n = parseFloat(val); 20806 return isNaN(n) ? val : n 20807} 20808 20809/** 20810 * Make a map and return a function for checking if a key 20811 * is in that map. 20812 */ 20813function makeMap ( 20814 str, 20815 expectsLowerCase 20816) { 20817 var map = Object.create(null); 20818 var list = str.split(','); 20819 for (var i = 0; i < list.length; i++) { 20820 map[list[i]] = true; 20821 } 20822 return expectsLowerCase 20823 ? function (val) { return map[val.toLowerCase()]; } 20824 : function (val) { return map[val]; } 20825} 20826 20827/** 20828 * Check if a tag is a built-in tag. 20829 */ 20830var isBuiltInTag = makeMap('slot,component', true); 20831 20832/** 20833 * Check if a attribute is a reserved attribute. 20834 */ 20835var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); 20836 20837/** 20838 * Remove an item from an array 20839 */ 20840function remove (arr, item) { 20841 if (arr.length) { 20842 var index = arr.indexOf(item); 20843 if (index > -1) { 20844 return arr.splice(index, 1) 20845 } 20846 } 20847} 20848 20849/** 20850 * Check whether the object has the property. 20851 */ 20852var hasOwnProperty = Object.prototype.hasOwnProperty; 20853function hasOwn (obj, key) { 20854 return hasOwnProperty.call(obj, key) 20855} 20856 20857/** 20858 * Create a cached version of a pure function. 20859 */ 20860function cached (fn) { 20861 var cache = Object.create(null); 20862 return (function cachedFn (str) { 20863 var hit = cache[str]; 20864 return hit || (cache[str] = fn(str)) 20865 }) 20866} 20867 20868/** 20869 * Camelize a hyphen-delimited string. 20870 */ 20871var camelizeRE = /-(\w)/g; 20872var camelize = cached(function (str) { 20873 return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; }) 20874}); 20875 20876/** 20877 * Capitalize a string. 20878 */ 20879var capitalize = cached(function (str) { 20880 return str.charAt(0).toUpperCase() + str.slice(1) 20881}); 20882 20883/** 20884 * Hyphenate a camelCase string. 20885 */ 20886var hyphenateRE = /\B([A-Z])/g; 20887var hyphenate = cached(function (str) { 20888 return str.replace(hyphenateRE, '-$1').toLowerCase() 20889}); 20890 20891/** 20892 * Simple bind, faster than native 20893 */ 20894function bind (fn, ctx) { 20895 function boundFn (a) { 20896 var l = arguments.length; 20897 return l 20898 ? l > 1 20899 ? fn.apply(ctx, arguments) 20900 : fn.call(ctx, a) 20901 : fn.call(ctx) 20902 } 20903 // record original fn length 20904 boundFn._length = fn.length; 20905 return boundFn 20906} 20907 20908/** 20909 * Convert an Array-like object to a real Array. 20910 */ 20911function toArray (list, start) { 20912 start = start || 0; 20913 var i = list.length - start; 20914 var ret = new Array(i); 20915 while (i--) { 20916 ret[i] = list[i + start]; 20917 } 20918 return ret 20919} 20920 20921/** 20922 * Mix properties into target object. 20923 */ 20924function extend (to, _from) { 20925 for (var key in _from) { 20926 to[key] = _from[key]; 20927 } 20928 return to 20929} 20930 20931/** 20932 * Merge an Array of Objects into a single Object. 20933 */ 20934function toObject (arr) { 20935 var res = {}; 20936 for (var i = 0; i < arr.length; i++) { 20937 if (arr[i]) { 20938 extend(res, arr[i]); 20939 } 20940 } 20941 return res 20942} 20943 20944/** 20945 * Perform no operation. 20946 * Stubbing args to make Flow happy without leaving useless transpiled code 20947 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/) 20948 */ 20949function noop (a, b, c) {} 20950 20951/** 20952 * Always return false. 20953 */ 20954var no = function (a, b, c) { return false; }; 20955 20956/** 20957 * Return same value 20958 */ 20959var identity = function (_) { return _; }; 20960 20961/** 20962 * Generate a static keys string from compiler modules. 20963 */ 20964function genStaticKeys (modules) { 20965 return modules.reduce(function (keys, m) { 20966 return keys.concat(m.staticKeys || []) 20967 }, []).join(',') 20968} 20969 20970/** 20971 * Check if two values are loosely equal - that is, 20972 * if they are plain objects, do they have the same shape? 20973 */ 20974function looseEqual (a, b) { 20975 if (a === b) { return true } 20976 var isObjectA = isObject(a); 20977 var isObjectB = isObject(b); 20978 if (isObjectA && isObjectB) { 20979 try { 20980 var isArrayA = Array.isArray(a); 20981 var isArrayB = Array.isArray(b); 20982 if (isArrayA && isArrayB) { 20983 return a.length === b.length && a.every(function (e, i) { 20984 return looseEqual(e, b[i]) 20985 }) 20986 } else if (!isArrayA && !isArrayB) { 20987 var keysA = Object.keys(a); 20988 var keysB = Object.keys(b); 20989 return keysA.length === keysB.length && keysA.every(function (key) { 20990 return looseEqual(a[key], b[key]) 20991 }) 20992 } else { 20993 /* istanbul ignore next */ 20994 return false 20995 } 20996 } catch (e) { 20997 /* istanbul ignore next */ 20998 return false 20999 } 21000 } else if (!isObjectA && !isObjectB) { 21001 return String(a) === String(b) 21002 } else { 21003 return false 21004 } 21005} 21006 21007function looseIndexOf (arr, val) { 21008 for (var i = 0; i < arr.length; i++) { 21009 if (looseEqual(arr[i], val)) { return i } 21010 } 21011 return -1 21012} 21013 21014/** 21015 * Ensure a function is called only once. 21016 */ 21017function once (fn) { 21018 var called = false;
vendor: 4,330 bytes, lines 21019-21223
21019 return function () { 21020 if (!called) { 21021 called = true; 21022 fn.apply(this, arguments); 21023 } 21024 } 21025} 21026 21027var SSR_ATTR = 'data-server-rendered'; 21028 21029var ASSET_TYPES = [ 21030 'component', 21031 'directive', 21032 'filter' 21033]; 21034 21035var LIFECYCLE_HOOKS = [ 21036 'beforeCreate', 21037 'created', 21038 'beforeMount', 21039 'mounted', 21040 'beforeUpdate', 21041 'updated', 21042 'beforeDestroy', 21043 'destroyed', 21044 'activated', 21045 'deactivated', 21046 'errorCaptured' 21047]; 21048 21049/* */ 21050 21051var config = ({ 21052 /** 21053 * Option merge strategies (used in core/util/options) 21054 */ 21055 optionMergeStrategies: Object.create(null), 21056 21057 /** 21058 * Whether to suppress warnings. 21059 */ 21060 silent: false, 21061 21062 /** 21063 * Show production mode tip message on boot? 21064 */ 21065 productionTip: "development" !== 'production', 21066 21067 /** 21068 * Whether to enable devtools 21069 */ 21070 devtools: "development" !== 'production', 21071 21072 /** 21073 * Whether to record perf 21074 */ 21075 performance: false, 21076 21077 /** 21078 * Error handler for watcher errors 21079 */ 21080 errorHandler: null, 21081 21082 /** 21083 * Warn handler for watcher warns 21084 */ 21085 warnHandler: null, 21086 21087 /** 21088 * Ignore certain custom elements 21089 */ 21090 ignoredElements: [], 21091 21092 /** 21093 * Custom user key aliases for v-on 21094 */ 21095 keyCodes: Object.create(null), 21096 21097 /** 21098 * Check if a tag is reserved so that it cannot be registered as a 21099 * component. This is platform-dependent and may be overwritten. 21100 */ 21101 isReservedTag: no, 21102 21103 /** 21104 * Check if an attribute is reserved so that it cannot be used as a component 21105 * prop. This is platform-dependent and may be overwritten. 21106 */ 21107 isReservedAttr: no, 21108 21109 /** 21110 * Check if a tag is an unknown element. 21111 * Platform-dependent. 21112 */ 21113 isUnknownElement: no, 21114 21115 /** 21116 * Get the namespace of an element 21117 */ 21118 getTagNamespace: noop, 21119 21120 /** 21121 * Parse the real tag name for the specific platform. 21122 */ 21123 parsePlatformTagName: identity, 21124 21125 /** 21126 * Check if an attribute must be bound using property, e.g. value 21127 * Platform-dependent. 21128 */ 21129 mustUseProp: no, 21130 21131 /** 21132 * Exposed for legacy reasons 21133 */ 21134 _lifecycleHooks: LIFECYCLE_HOOKS 21135}); 21136 21137/* */ 21138 21139/** 21140 * Check if a string starts with $ or _ 21141 */ 21142function isReserved (str) { 21143 var c = (str + '').charCodeAt(0); 21144 return c === 0x24 || c === 0x5F 21145} 21146 21147/** 21148 * Define a property. 21149 */ 21150function def (obj, key, val, enumerable) { 21151 Object.defineProperty(obj, key, { 21152 value: val, 21153 enumerable: !!enumerable, 21154 writable: true, 21155 configurable: true 21156 }); 21157} 21158 21159/** 21160 * Parse simple path. 21161 */ 21162var bailRE = /[^\w.$]/; 21163function parsePath (path) { 21164 if (bailRE.test(path)) { 21165 return 21166 } 21167 var segments = path.split('.'); 21168 return function (obj) { 21169 for (var i = 0; i < segments.length; i++) { 21170 if (!obj) { return } 21171 obj = obj[segments[i]]; 21172 } 21173 return obj 21174 } 21175} 21176 21177/* */ 21178 21179 21180// can we use __proto__? 21181var hasProto = '__proto__' in {}; 21182 21183// Browser environment sniffing 21184var inBrowser = typeof window !== 'undefined'; 21185var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; 21186var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); 21187var UA = inBrowser && window.navigator.userAgent.toLowerCase(); 21188var isIE = UA && /msie|trident/.test(UA); 21189var isIE9 = UA && UA.indexOf('msie 9.0') > 0; 21190var isEdge = UA && UA.indexOf('edge/') > 0; 21191var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android'); 21192var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios'); 21193var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; 21194 21195// Firefox has a "watch" function on Object.prototype... 21196var nativeWatch = ({}).watch; 21197 21198var supportsPassive = false; 21199if (inBrowser) { 21200 try { 21201 var opts = {}; 21202 Object.defineProperty(opts, 'passive', ({ 21203 get: function get () { 21204 /* istanbul ignore next */ 21205 supportsPassive = true; 21206 } 21207 })); // https://github.com/facebook/flow/issues/285 21208 window.addEventListener('test-passive', null, opts); 21209 } catch (e) {} 21210} 21211 21212// this needs to be lazy-evaled because vue may be required before 21213// vue-server-renderer can set VUE_ENV 21214var _isServer; 21215var isServerRendering = function () { 21216 if (_isServer === undefined) { 21217 /* istanbul ignore if */ 21218 if (!inBrowser && typeof global !== 'undefined') { 21219 // detect presence of vue-server-renderer and avoid 21220 // Webpack shimming the process 21221 _isServer = global['process'].env.VUE_ENV === 'server'; 21222 } else { 21223 _isServer = false;
vendor: 14,891 bytes, lines 21224-21844
21224 } 21225 } 21226 return _isServer 21227}; 21228 21229// detect devtools 21230var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; 21231 21232/* istanbul ignore next */ 21233function isNative (Ctor) { 21234 return typeof Ctor === 'function' && /native code/.test(Ctor.toString()) 21235} 21236 21237var hasSymbol = 21238 typeof Symbol !== 'undefined' && isNative(Symbol) && 21239 typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); 21240 21241var _Set; 21242/* istanbul ignore if */ // $flow-disable-line 21243if (typeof Set !== 'undefined' && isNative(Set)) { 21244 // use native Set when available. 21245 _Set = Set; 21246} else { 21247 // a non-standard Set polyfill that only works with primitive keys. 21248 _Set = (function () { 21249 function Set () { 21250 this.set = Object.create(null); 21251 } 21252 Set.prototype.has = function has (key) { 21253 return this.set[key] === true 21254 }; 21255 Set.prototype.add = function add (key) { 21256 this.set[key] = true; 21257 }; 21258 Set.prototype.clear = function clear () { 21259 this.set = Object.create(null); 21260 }; 21261 21262 return Set; 21263 }()); 21264} 21265 21266/* */ 21267 21268var warn = noop; 21269var tip = noop; 21270var generateComponentTrace = (noop); // work around flow check 21271var formatComponentName = (noop); 21272 21273{ 21274 var hasConsole = typeof console !== 'undefined'; 21275 var classifyRE = /(?:^|[-_])(\w)/g; 21276 var classify = function (str) { return str 21277 .replace(classifyRE, function (c) { return c.toUpperCase(); }) 21278 .replace(/[-_]/g, ''); }; 21279 21280 warn = function (msg, vm) { 21281 var trace = vm ? generateComponentTrace(vm) : ''; 21282 21283 if (config.warnHandler) { 21284 config.warnHandler.call(null, msg, vm, trace); 21285 } else if (hasConsole && (!config.silent)) { 21286 console.error(("[Vue warn]: " + msg + trace)); 21287 } 21288 }; 21289 21290 tip = function (msg, vm) { 21291 if (hasConsole && (!config.silent)) { 21292 console.warn("[Vue tip]: " + msg + ( 21293 vm ? generateComponentTrace(vm) : '' 21294 )); 21295 } 21296 }; 21297 21298 formatComponentName = function (vm, includeFile) { 21299 if (vm.$root === vm) { 21300 return '<Root>' 21301 } 21302 var options = typeof vm === 'function' && vm.cid != null 21303 ? vm.options 21304 : vm._isVue 21305 ? vm.$options || vm.constructor.options 21306 : vm || {}; 21307 var name = options.name || options._componentTag; 21308 var file = options.__file; 21309 if (!name && file) { 21310 var match = file.match(/([^/\\]+)\.vue$/); 21311 name = match && match[1]; 21312 } 21313 21314 return ( 21315 (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") + 21316 (file && includeFile !== false ? (" at " + file) : '') 21317 ) 21318 }; 21319 21320 var repeat = function (str, n) { 21321 var res = ''; 21322 while (n) { 21323 if (n % 2 === 1) { res += str; } 21324 if (n > 1) { str += str; } 21325 n >>= 1; 21326 } 21327 return res 21328 }; 21329 21330 generateComponentTrace = function (vm) { 21331 if (vm._isVue && vm.$parent) { 21332 var tree = []; 21333 var currentRecursiveSequence = 0; 21334 while (vm) { 21335 if (tree.length > 0) { 21336 var last = tree[tree.length - 1]; 21337 if (last.constructor === vm.constructor) { 21338 currentRecursiveSequence++; 21339 vm = vm.$parent; 21340 continue 21341 } else if (currentRecursiveSequence > 0) { 21342 tree[tree.length - 1] = [last, currentRecursiveSequence]; 21343 currentRecursiveSequence = 0; 21344 } 21345 } 21346 tree.push(vm); 21347 vm = vm.$parent; 21348 } 21349 return '\n\nfound in\n\n' + tree 21350 .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm) 21351 ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)") 21352 : formatComponentName(vm))); }) 21353 .join('\n') 21354 } else { 21355 return ("\n\n(found in " + (formatComponentName(vm)) + ")") 21356 } 21357 }; 21358} 21359 21360/* */ 21361 21362 21363var uid = 0; 21364 21365/** 21366 * A dep is an observable that can have multiple 21367 * directives subscribing to it. 21368 */ 21369var Dep = function Dep () { 21370 this.id = uid++; 21371 this.subs = []; 21372}; 21373 21374Dep.prototype.addSub = function addSub (sub) { 21375 this.subs.push(sub); 21376}; 21377 21378Dep.prototype.removeSub = function removeSub (sub) { 21379 remove(this.subs, sub); 21380}; 21381 21382Dep.prototype.depend = function depend () { 21383 if (Dep.target) { 21384 Dep.target.addDep(this); 21385 } 21386}; 21387 21388Dep.prototype.notify = function notify () { 21389 // stabilize the subscriber list first 21390 var subs = this.subs.slice(); 21391 for (var i = 0, l = subs.length; i < l; i++) { 21392 subs[i].update(); 21393 } 21394}; 21395 21396// the current target watcher being evaluated. 21397// this is globally unique because there could be only one 21398// watcher being evaluated at any time. 21399Dep.target = null; 21400var targetStack = []; 21401 21402function pushTarget (_target) { 21403 if (Dep.target) { targetStack.push(Dep.target); } 21404 Dep.target = _target; 21405} 21406 21407function popTarget () { 21408 Dep.target = targetStack.pop(); 21409} 21410 21411/* */ 21412 21413var VNode = function VNode ( 21414 tag, 21415 data, 21416 children, 21417 text, 21418 elm, 21419 context, 21420 componentOptions, 21421 asyncFactory 21422) { 21423 this.tag = tag; 21424 this.data = data; 21425 this.children = children; 21426 this.text = text; 21427 this.elm = elm; 21428 this.ns = undefined; 21429 this.context = context; 21430 this.functionalContext = undefined; 21431 this.functionalOptions = undefined; 21432 this.functionalScopeId = undefined; 21433 this.key = data && data.key; 21434 this.componentOptions = componentOptions; 21435 this.componentInstance = undefined; 21436 this.parent = undefined; 21437 this.raw = false; 21438 this.isStatic = false; 21439 this.isRootInsert = true; 21440 this.isComment = false; 21441 this.isCloned = false; 21442 this.isOnce = false; 21443 this.asyncFactory = asyncFactory; 21444 this.asyncMeta = undefined; 21445 this.isAsyncPlaceholder = false; 21446}; 21447 21448var prototypeAccessors = { child: { configurable: true } }; 21449 21450// DEPRECATED: alias for componentInstance for backwards compat. 21451/* istanbul ignore next */ 21452prototypeAccessors.child.get = function () { 21453 return this.componentInstance 21454}; 21455 21456Object.defineProperties( VNode.prototype, prototypeAccessors ); 21457 21458var createEmptyVNode = function (text) { 21459 if ( text === void 0 ) text = ''; 21460 21461 var node = new VNode(); 21462 node.text = text; 21463 node.isComment = true; 21464 return node 21465}; 21466 21467function createTextVNode (val) { 21468 return new VNode(undefined, undefined, undefined, String(val)) 21469} 21470 21471// optimized shallow clone 21472// used for static nodes and slot nodes because they may be reused across 21473// multiple renders, cloning them avoids errors when DOM manipulations rely 21474// on their elm reference. 21475function cloneVNode (vnode, deep) { 21476 var componentOptions = vnode.componentOptions; 21477 var cloned = new VNode( 21478 vnode.tag, 21479 vnode.data, 21480 vnode.children, 21481 vnode.text, 21482 vnode.elm, 21483 vnode.context, 21484 componentOptions, 21485 vnode.asyncFactory 21486 ); 21487 cloned.ns = vnode.ns; 21488 cloned.isStatic = vnode.isStatic; 21489 cloned.key = vnode.key; 21490 cloned.isComment = vnode.isComment; 21491 cloned.isCloned = true; 21492 if (deep) { 21493 if (vnode.children) { 21494 cloned.children = cloneVNodes(vnode.children, true); 21495 } 21496 if (componentOptions && componentOptions.children) { 21497 componentOptions.children = cloneVNodes(componentOptions.children, true); 21498 } 21499 } 21500 return cloned 21501} 21502 21503function cloneVNodes (vnodes, deep) { 21504 var len = vnodes.length; 21505 var res = new Array(len); 21506 for (var i = 0; i < len; i++) { 21507 res[i] = cloneVNode(vnodes[i], deep); 21508 } 21509 return res 21510} 21511 21512/* 21513 * not type checking this file because flow doesn't play well with 21514 * dynamically accessing methods on Array prototype 21515 */ 21516 21517var arrayProto = Array.prototype; 21518var arrayMethods = Object.create(arrayProto);[ 21519 'push', 21520 'pop', 21521 'shift', 21522 'unshift', 21523 'splice', 21524 'sort', 21525 'reverse' 21526] 21527.forEach(function (method) { 21528 // cache original method 21529 var original = arrayProto[method]; 21530 def(arrayMethods, method, function mutator () { 21531 var args = [], len = arguments.length; 21532 while ( len-- ) args[ len ] = arguments[ len ]; 21533 21534 var result = original.apply(this, args); 21535 var ob = this.__ob__; 21536 var inserted; 21537 switch (method) { 21538 case 'push': 21539 case 'unshift': 21540 inserted = args; 21541 break 21542 case 'splice': 21543 inserted = args.slice(2); 21544 break 21545 } 21546 if (inserted) { ob.observeArray(inserted); } 21547 // notify change 21548 ob.dep.notify(); 21549 return result 21550 }); 21551}); 21552 21553/* */ 21554 21555var arrayKeys = Object.getOwnPropertyNames(arrayMethods); 21556 21557/** 21558 * By default, when a reactive property is set, the new value is 21559 * also converted to become reactive. However when passing down props, 21560 * we don't want to force conversion because the value may be a nested value 21561 * under a frozen data structure. Converting it would defeat the optimization. 21562 */ 21563var observerState = { 21564 shouldConvert: true 21565}; 21566 21567/** 21568 * Observer class that are attached to each observed 21569 * object. Once attached, the observer converts target 21570 * object's property keys into getter/setters that 21571 * collect dependencies and dispatches updates. 21572 */ 21573var Observer = function Observer (value) { 21574 this.value = value; 21575 this.dep = new Dep(); 21576 this.vmCount = 0; 21577 def(value, '__ob__', this); 21578 if (Array.isArray(value)) { 21579 var augment = hasProto 21580 ? protoAugment 21581 : copyAugment; 21582 augment(value, arrayMethods, arrayKeys); 21583 this.observeArray(value); 21584 } else { 21585 this.walk(value); 21586 } 21587}; 21588 21589/** 21590 * Walk through each property and convert them into 21591 * getter/setters. This method should only be called when 21592 * value type is Object. 21593 */ 21594Observer.prototype.walk = function walk (obj) { 21595 var keys = Object.keys(obj); 21596 for (var i = 0; i < keys.length; i++) { 21597 defineReactive(obj, keys[i], obj[keys[i]]); 21598 } 21599}; 21600 21601/** 21602 * Observe a list of Array items. 21603 */ 21604Observer.prototype.observeArray = function observeArray (items) { 21605 for (var i = 0, l = items.length; i < l; i++) { 21606 observe(items[i]); 21607 } 21608}; 21609 21610// helpers 21611 21612/** 21613 * Augment an target Object or Array by intercepting 21614 * the prototype chain using __proto__ 21615 */ 21616function protoAugment (target, src, keys) { 21617 /* eslint-disable no-proto */ 21618 target.__proto__ = src; 21619 /* eslint-enable no-proto */ 21620} 21621 21622/** 21623 * Augment an target Object or Array by defining 21624 * hidden properties. 21625 */ 21626/* istanbul ignore next */ 21627function copyAugment (target, src, keys) { 21628 for (var i = 0, l = keys.length; i < l; i++) { 21629 var key = keys[i]; 21630 def(target, key, src[key]); 21631 } 21632} 21633 21634/** 21635 * Attempt to create an observer instance for a value, 21636 * returns the new observer if successfully observed, 21637 * or the existing observer if the value already has one. 21638 */ 21639function observe (value, asRootData) { 21640 if (!isObject(value) || value instanceof VNode) { 21641 return 21642 } 21643 var ob; 21644 if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { 21645 ob = value.__ob__; 21646 } else if ( 21647 observerState.shouldConvert && 21648 !isServerRendering() && 21649 (Array.isArray(value) || isPlainObject(value)) && 21650 Object.isExtensible(value) && 21651 !value._isVue 21652 ) { 21653 ob = new Observer(value); 21654 } 21655 if (asRootData && ob) { 21656 ob.vmCount++; 21657 } 21658 return ob 21659} 21660 21661/** 21662 * Define a reactive property on an Object. 21663 */ 21664function defineReactive ( 21665 obj, 21666 key, 21667 val, 21668 customSetter, 21669 shallow 21670) { 21671 var dep = new Dep(); 21672 21673 var property = Object.getOwnPropertyDescriptor(obj, key); 21674 if (property && property.configurable === false) { 21675 return 21676 } 21677 21678 // cater for pre-defined getter/setters 21679 var getter = property && property.get; 21680 var setter = property && property.set; 21681 21682 var childOb = !shallow && observe(val); 21683 Object.defineProperty(obj, key, { 21684 enumerable: true, 21685 configurable: true, 21686 get: function reactiveGetter () { 21687 var value = getter ? getter.call(obj) : val; 21688 if (Dep.target) { 21689 dep.depend(); 21690 if (childOb) { 21691 childOb.dep.depend(); 21692 if (Array.isArray(value)) { 21693 dependArray(value); 21694 } 21695 } 21696 } 21697 return value 21698 }, 21699 set: function reactiveSetter (newVal) { 21700 var value = getter ? getter.call(obj) : val; 21701 /* eslint-disable no-self-compare */ 21702 if (newVal === value || (newVal !== newVal && value !== value)) { 21703 return 21704 } 21705 /* eslint-enable no-self-compare */ 21706 if ("development" !== 'production' && customSetter) { 21707 customSetter(); 21708 } 21709 if (setter) { 21710 setter.call(obj, newVal); 21711 } else { 21712 val = newVal; 21713 } 21714 childOb = !shallow && observe(newVal); 21715 dep.notify(); 21716 } 21717 }); 21718} 21719 21720/** 21721 * Set a property on an object. Adds the new property and 21722 * triggers change notification if the property doesn't 21723 * already exist. 21724 */ 21725function set (target, key, val) { 21726 if (Array.isArray(target) && isValidArrayIndex(key)) { 21727 target.length = Math.max(target.length, key); 21728 target.splice(key, 1, val); 21729 return val 21730 } 21731 if (key in target && !(key in Object.prototype)) { 21732 target[key] = val; 21733 return val 21734 } 21735 var ob = (target).__ob__; 21736 if (target._isVue || (ob && ob.vmCount)) { 21737 "development" !== 'production' && warn( 21738 'Avoid adding reactive properties to a Vue instance or its root $data ' + 21739 'at runtime - declare it upfront in the data option.' 21740 ); 21741 return val 21742 } 21743 if (!ob) { 21744 target[key] = val; 21745 return val 21746 } 21747 defineReactive(ob.value, key, val); 21748 ob.dep.notify(); 21749 return val 21750} 21751 21752/** 21753 * Delete a property and trigger change if necessary. 21754 */ 21755function del (target, key) { 21756 if (Array.isArray(target) && isValidArrayIndex(key)) { 21757 target.splice(key, 1); 21758 return 21759 } 21760 var ob = (target).__ob__; 21761 if (target._isVue || (ob && ob.vmCount)) { 21762 "development" !== 'production' && warn( 21763 'Avoid deleting properties on a Vue instance or its root $data ' + 21764 '- just set it to null.' 21765 ); 21766 return 21767 } 21768 if (!hasOwn(target, key)) { 21769 return 21770 } 21771 delete target[key]; 21772 if (!ob) { 21773 return 21774 } 21775 ob.dep.notify(); 21776} 21777 21778/** 21779 * Collect dependencies on array elements when the array is touched, since 21780 * we cannot intercept array element access like property getters. 21781 */ 21782function dependArray (value) { 21783 for (var e = (void 0), i = 0, l = value.length; i < l; i++) { 21784 e = value[i]; 21785 e && e.__ob__ && e.__ob__.dep.depend(); 21786 if (Array.isArray(e)) { 21787 dependArray(e); 21788 } 21789 } 21790} 21791 21792/* */ 21793 21794/** 21795 * Option overwriting strategies are functions that handle 21796 * how to merge a parent option value and a child option 21797 * value into the final value. 21798 */ 21799var strats = config.optionMergeStrategies; 21800 21801/** 21802 * Options with restrictions 21803 */ 21804{ 21805 strats.el = strats.propsData = function (parent, child, vm, key) { 21806 if (!vm) { 21807 warn( 21808 "option \"" + key + "\" can only be used during instance " + 21809 'creation with the `new` keyword.' 21810 ); 21811 } 21812 return defaultStrat(parent, child) 21813 }; 21814} 21815 21816/** 21817 * Helper that recursively merges two data objects together. 21818 */ 21819function mergeData (to, from) { 21820 if (!from) { return to } 21821 var key, toVal, fromVal; 21822 var keys = Object.keys(from); 21823 for (var i = 0; i < keys.length; i++) { 21824 key = keys[i]; 21825 toVal = to[key]; 21826 fromVal = from[key]; 21827 if (!hasOwn(to, key)) { 21828 set(to, key, fromVal); 21829 } else if (isPlainObject(toVal) && isPlainObject(fromVal)) { 21830 mergeData(toVal, fromVal); 21831 } 21832 } 21833 return to 21834} 21835 21836/** 21837 * Data 21838 */ 21839function mergeDataOrFn ( 21840 parentVal, 21841 childVal, 21842 vm 21843) { 21844 if (!vm) {
21845 // in a Vue.extend merge, both should be functions 21846 if (!childVal) { 21847 return parentVal 21848 } 21849 if (!parentVal) { 21850 return childVal 21851 } 21852 // when parentVal & childVal are both present, 21853 // we need to return a function that returns the 21854 // merged result of both functions... no need to 21855 // check if parentVal is a function here because 21856 // it has to be a function to pass previous merges. 21857 return function mergedDataFn () { 21858 return mergeData( 21859 typeof childVal === 'function' ? childVal.call(this) : childVal, 21860 typeof parentVal === 'function' ? parentVal.call(this) : parentVal 21861 ) 21862 } 21863 } else { 21864 return function mergedInstanceDataFn () { 21865 // instance merge 21866 var instanceData = typeof childVal === 'function' 21867 ? childVal.call(vm) 21868 : childVal; 21869 var defaultData = typeof parentVal === 'function' 21870 ? parentVal.call(vm) 21871 : parentVal; 21872 if (instanceData) { 21873 return mergeData(instanceData, defaultData) 21874 } else { 21875 return defaultData 21876 } 21877 } 21878 } 21879} 21880 21881strats.data = function ( 21882 parentVal, 21883 childVal, 21884 vm 21885) { 21886 if (!vm) { 21887 if (childVal && typeof childVal !== 'function') { 21888 "development" !== 'production' && warn( 21889 'The "data" option should be a function ' + 21890 'that returns a per-instance value in component ' + 21891 'definitions.', 21892 vm 21893 ); 21894 21895 return parentVal 21896 } 21897 return mergeDataOrFn(parentVal, childVal) 21898 } 21899 21900 return mergeDataOrFn(parentVal, childVal, vm) 21901}; 21902 21903/** 21904 * Hooks and props are merged as arrays. 21905 */ 21906function mergeHook ( 21907 parentVal, 21908 childVal 21909) { 21910 return childVal 21911 ? parentVal 21912 ? parentVal.concat(childVal) 21913 : Array.isArray(childVal) 21914 ? childVal 21915 : [childVal] 21916 : parentVal 21917} 21918 21919LIFECYCLE_HOOKS.forEach(function (hook) { 21920 strats[hook] = mergeHook; 21921}); 21922 21923/** 21924 * Assets 21925 * 21926 * When a vm is present (instance creation), we need to do 21927 * a three-way merge between constructor options, instance 21928 * options and parent options. 21929 */ 21930function mergeAssets ( 21931 parentVal, 21932 childVal, 21933 vm, 21934 key 21935) { 21936 var res = Object.create(parentVal || null); 21937 if (childVal) { 21938 "development" !== 'production' && assertObjectType(key, childVal, vm); 21939 return extend(res, childVal) 21940 } else { 21941 return res 21942 } 21943} 21944 21945ASSET_TYPES.forEach(function (type) { 21946 strats[type + 's'] = mergeAssets; 21947}); 21948 21949/** 21950 * Watchers. 21951 * 21952 * Watchers hashes should not overwrite one 21953 * another, so we merge them as arrays. 21954 */ 21955strats.watch = function ( 21956 parentVal, 21957 childVal, 21958 vm, 21959 key 21960) { 21961 // work around Firefox's Object.prototype.watch... 21962 if (parentVal === nativeWatch) { parentVal = undefined; } 21963 if (childVal === nativeWatch) { childVal = undefined; } 21964 /* istanbul ignore if */ 21965 if (!childVal) { return Object.create(parentVal || null) } 21966 { 21967 assertObjectType(key, childVal, vm); 21968 } 21969 if (!parentVal) { return childVal } 21970 var ret = {}; 21971 extend(ret, parentVal); 21972 for (var key$1 in childVal) { 21973 var parent = ret[key$1]; 21974 var child = childVal[key$1]; 21975 if (parent && !Array.isArray(parent)) { 21976 parent = [parent]; 21977 } 21978 ret[key$1] = parent 21979 ? parent.concat(child) 21980 : Array.isArray(child) ? child : [child]; 21981 } 21982 return ret 21983}; 21984 21985/** 21986 * Other object hashes. 21987 */ 21988strats.props = 21989strats.methods = 21990strats.inject = 21991strats.computed = function ( 21992 parentVal, 21993 childVal, 21994 vm, 21995 key 21996) { 21997 if (childVal && "development" !== 'production') { 21998 assertObjectType(key, childVal, vm); 21999 } 22000 if (!parentVal) { return childVal } 22001 var ret = Object.create(null); 22002 extend(ret, parentVal); 22003 if (childVal) { extend(ret, childVal); } 22004 return ret 22005}; 22006strats.provide = mergeDataOrFn; 22007 22008/** 22009 * Default strategy. 22010 */ 22011var defaultStrat = function (parentVal, childVal) { 22012 return childVal === undefined 22013 ? parentVal 22014 : childVal 22015}; 22016 22017/** 22018 * Validate component names 22019 */ 22020function checkComponents (options) { 22021 for (var key in options.components) { 22022 var lower = key.toLowerCase(); 22023 if (isBuiltInTag(lower) || config.isReservedTag(lower)) { 22024 warn( 22025 'Do not use built-in or reserved HTML elements as component ' + 22026 'id: ' + key 22027 ); 22028 } 22029 } 22030} 22031 22032/** 22033 * Ensure all props option syntax are normalized into the 22034 * Object-based format. 22035 */ 22036function normalizeProps (options, vm) { 22037 var props = options.props; 22038 if (!props) { return } 22039 var res = {}; 22040 var i, val, name; 22041 if (Array.isArray(props)) { 22042 i = props.length; 22043 while (i--) { 22044 val = props[i]; 22045 if (typeof val === 'string') { 22046 name = camelize(val); 22047 res[name] = { type: null }; 22048 } else { 22049 warn('props must be strings when using array syntax.'); 22050 } 22051 } 22052 } else if (isPlainObject(props)) { 22053 for (var key in props) { 22054 val = props[key]; 22055 name = camelize(key); 22056 res[name] = isPlainObject(val) 22057 ? val 22058 : { type: val }; 22059 } 22060 } else { 22061 warn( 22062 "Invalid value for option \"props\": expected an Array or an Object, " + 22063 "but got " + (toRawType(props)) + ".", 22064 vm 22065 ); 22066 } 22067 options.props = res; 22068} 22069 22070/** 22071 * Normalize all injections into Object-based format 22072 */ 22073function normalizeInject (options, vm) { 22074 var inject = options.inject; 22075 var normalized = options.inject = {}; 22076 if (Array.isArray(inject)) { 22077 for (var i = 0; i < inject.length; i++) { 22078 normalized[inject[i]] = { from: inject[i] }; 22079 } 22080 } else if (isPlainObject(inject)) { 22081 for (var key in inject) { 22082 var val = inject[key]; 22083 normalized[key] = isPlainObject(val) 22084 ? extend({ from: key }, val) 22085 : { from: val }; 22086 } 22087 } else if ("development" !== 'production' && inject) { 22088 warn( 22089 "Invalid value for option \"inject\": expected an Array or an Object, " + 22090 "but got " + (toRawType(inject)) + ".", 22091 vm 22092 ); 22093 } 22094} 22095 22096/** 22097 * Normalize raw function directives into object format. 22098 */ 22099function normalizeDirectives (options) { 22100 var dirs = options.directives; 22101 if (dirs) { 22102 for (var key in dirs) { 22103 var def = dirs[key]; 22104 if (typeof def === 'function') { 22105 dirs[key] = { bind: def, update: def }; 22106 } 22107 } 22108 } 22109} 22110 22111function assertObjectType (name, value, vm) { 22112 if (!isPlainObject(value)) { 22113 warn( 22114 "Invalid value for option \"" + name + "\": expected an Object, " + 22115 "but got " + (toRawType(value)) + ".", 22116 vm 22117 ); 22118 } 22119} 22120 22121/** 22122 * Merge two option objects into a new one. 22123 * Core utility used in both instantiation and inheritance. 22124 */ 22125function mergeOptions ( 22126 parent, 22127 child, 22128 vm 22129) { 22130 { 22131 checkComponents(child); 22132 } 22133 22134 if (typeof child === 'function') { 22135 child = child.options; 22136 } 22137 22138 normalizeProps(child, vm); 22139 normalizeInject(child, vm); 22140 normalizeDirectives(child); 22141 var extendsFrom = child.extends; 22142 if (extendsFrom) { 22143 parent = mergeOptions(parent, extendsFrom, vm); 22144 } 22145 if (child.mixins) { 22146 for (var i = 0, l = child.mixins.length; i < l; i++) { 22147 parent = mergeOptions(parent, child.mixins[i], vm); 22148 } 22149 } 22150 var options = {}; 22151 var key; 22152 for (key in parent) { 22153 mergeField(key); 22154 } 22155 for (key in child) { 22156 if (!hasOwn(parent, key)) { 22157 mergeField(key); 22158 } 22159 } 22160 function mergeField (key) { 22161 var strat = strats[key] || defaultStrat; 22162 options[key] = strat(parent[key], child[key], vm, key); 22163 } 22164 return options 22165} 22166 22167/** 22168 * Resolve an asset. 22169 * This function is used because child instances need access 22170 * to assets defined in its ancestor chain. 22171 */ 22172function resolveAsset ( 22173 options, 22174 type, 22175 id, 22176 warnMissing 22177) { 22178 /* istanbul ignore if */ 22179 if (typeof id !== 'string') { 22180 return 22181 } 22182 var assets = options[type]; 22183 // check local registration variations first 22184 if (hasOwn(assets, id)) { return assets[id] } 22185 var camelizedId = camelize(id); 22186 if (hasOwn(assets, camelizedId)) { return assets[camelizedId] } 22187 var PascalCaseId = capitalize(camelizedId); 22188 if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] } 22189 // fallback to prototype chain 22190 var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; 22191 if ("development" !== 'production' && warnMissing && !res) { 22192 warn( 22193 'Failed to resolve ' + type.slice(0, -1) + ': ' + id, 22194 options 22195 ); 22196 } 22197 return res 22198} 22199 22200/* */ 22201 22202function validateProp ( 22203 key, 22204 propOptions, 22205 propsData, 22206 vm 22207) { 22208 var prop = propOptions[key]; 22209 var absent = !hasOwn(propsData, key); 22210 var value = propsData[key]; 22211 // handle boolean props 22212 if (isType(Boolean, prop.type)) { 22213 if (absent && !hasOwn(prop, 'default')) { 22214 value = false;
vendor: 2,498 bytes, lines 22215-22309
22215 } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) { 22216 value = true; 22217 } 22218 } 22219 // check default value 22220 if (value === undefined) { 22221 value = getPropDefaultValue(vm, prop, key); 22222 // since the default value is a fresh copy, 22223 // make sure to observe it. 22224 var prevShouldConvert = observerState.shouldConvert; 22225 observerState.shouldConvert = true; 22226 observe(value); 22227 observerState.shouldConvert = prevShouldConvert; 22228 } 22229 { 22230 assertProp(prop, key, value, vm, absent); 22231 } 22232 return value 22233} 22234 22235/** 22236 * Get the default value of a prop. 22237 */ 22238function getPropDefaultValue (vm, prop, key) { 22239 // no default, return undefined 22240 if (!hasOwn(prop, 'default')) { 22241 return undefined 22242 } 22243 var def = prop.default; 22244 // warn against non-factory defaults for Object & Array 22245 if ("development" !== 'production' && isObject(def)) { 22246 warn( 22247 'Invalid default value for prop "' + key + '": ' + 22248 'Props with type Object/Array must use a factory function ' + 22249 'to return the default value.', 22250 vm 22251 ); 22252 } 22253 // the raw prop value was also undefined from previous render, 22254 // return previous default value to avoid unnecessary watcher trigger 22255 if (vm && vm.$options.propsData && 22256 vm.$options.propsData[key] === undefined && 22257 vm._props[key] !== undefined 22258 ) { 22259 return vm._props[key] 22260 } 22261 // call factory function for non-Function types 22262 // a value is Function if its prototype is function even across different execution context 22263 return typeof def === 'function' && getType(prop.type) !== 'Function' 22264 ? def.call(vm) 22265 : def 22266} 22267 22268/** 22269 * Assert whether a prop is valid. 22270 */ 22271function assertProp ( 22272 prop, 22273 name, 22274 value, 22275 vm, 22276 absent 22277) { 22278 if (prop.required && absent) { 22279 warn( 22280 'Missing required prop: "' + name + '"', 22281 vm 22282 ); 22283 return 22284 } 22285 if (value == null && !prop.required) { 22286 return 22287 } 22288 var type = prop.type; 22289 var valid = !type || type === true; 22290 var expectedTypes = []; 22291 if (type) { 22292 if (!Array.isArray(type)) { 22293 type = [type]; 22294 } 22295 for (var i = 0; i < type.length && !valid; i++) { 22296 var assertedType = assertType(value, type[i]); 22297 expectedTypes.push(assertedType.expectedType || ''); 22298 valid = assertedType.valid; 22299 } 22300 } 22301 if (!valid) { 22302 warn( 22303 "Invalid prop: type check failed for prop \"" + name + "\"." + 22304 " Expected " + (expectedTypes.map(capitalize).join(', ')) + 22305 ", got " + (toRawType(value)) + ".", 22306 vm 22307 ); 22308 return 22309 }
22310 var validator = prop.validator; 22311 if (validator) { 22312 if (!validator(value)) { 22313 warn( 22314 'Invalid prop: custom validator check failed for prop "' + name + '".', 22315 vm 22316 ); 22317 } 22318 } 22319} 22320 22321var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/; 22322 22323function assertType (value, type) { 22324 var valid; 22325 var expectedType = getType(type); 22326 if (simpleCheckRE.test(expectedType)) { 22327 var t = typeof value; 22328 valid = t === expectedType.toLowerCase(); 22329 // for primitive wrapper objects 22330 if (!valid && t === 'object') { 22331 valid = value instanceof type; 22332 } 22333 } else if (expectedType === 'Object') { 22334 valid = isPlainObject(value); 22335 } else if (expectedType === 'Array') { 22336 valid = Array.isArray(value); 22337 } else { 22338 valid = value instanceof type; 22339 } 22340 return { 22341 valid: valid, 22342 expectedType: expectedType 22343 } 22344} 22345 22346/** 22347 * Use function string name to check built-in types, 22348 * because a simple equality check will fail when running 22349 * across different vms / iframes. 22350 */ 22351function getType (fn) { 22352 var match = fn && fn.toString().match(/^\s*function (\w+)/); 22353 return match ? match[1] : '' 22354} 22355 22356function isType (type, fn) { 22357 if (!Array.isArray(fn)) { 22358 return getType(fn) === getType(type) 22359 } 22360 for (var i = 0, len = fn.length; i < len; i++) { 22361 if (getType(fn[i]) === getType(type)) { 22362 return true 22363 } 22364 } 22365 /* istanbul ignore next */ 22366 return false 22367} 22368 22369/* */ 22370 22371function handleError (err, vm, info) { 22372 if (vm) { 22373 var cur = vm; 22374 while ((cur = cur.$parent)) { 22375 var hooks = cur.$options.errorCaptured; 22376 if (hooks) { 22377 for (var i = 0; i < hooks.length; i++) { 22378 try { 22379 var capture = hooks[i].call(cur, err, vm, info) === false; 22380 if (capture) { return } 22381 } catch (e) { 22382 globalHandleError(e, cur, 'errorCaptured hook'); 22383 } 22384 } 22385 } 22386 } 22387 } 22388 globalHandleError(err, vm, info); 22389} 22390 22391function globalHandleError (err, vm, info) { 22392 if (config.errorHandler) { 22393 try { 22394 return config.errorHandler.call(null, err, vm, info) 22395 } catch (e) { 22396 logError(e, null, 'config.errorHandler'); 22397 } 22398 } 22399 logError(err, vm, info); 22400} 22401 22402function logError (err, vm, info) { 22403 { 22404 warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm); 22405 } 22406 /* istanbul ignore else */ 22407 if ((inBrowser || inWeex) && typeof console !== 'undefined') { 22408 console.error(err); 22409 } else { 22410 throw err 22411 } 22412} 22413 22414/* */ 22415/* globals MessageChannel */ 22416 22417var callbacks = []; 22418var pending = false; 22419 22420function flushCallbacks () { 22421 pending = false; 22422 var copies = callbacks.slice(0); 22423 callbacks.length = 0; 22424 for (var i = 0; i < copies.length; i++) { 22425 copies[i](); 22426 } 22427} 22428 22429// Here we have async deferring wrappers using both micro and macro tasks. 22430// In < 2.4 we used micro tasks everywhere, but there are some scenarios where 22431// micro tasks have too high a priority and fires in between supposedly 22432// sequential events (e.g. #4521, #6690) or even between bubbling of the same 22433// event (#6566). However, using macro tasks everywhere also has subtle problems 22434// when state is changed right before repaint (e.g. #6813, out-in transitions). 22435// Here we use micro task by default, but expose a way to force macro task when 22436// needed (e.g. in event handlers attached by v-on). 22437var microTimerFunc; 22438var macroTimerFunc; 22439var useMacroTask = false; 22440 22441// Determine (macro) Task defer implementation. 22442// Technically setImmediate should be the ideal choice, but it's only available 22443// in IE. The only polyfill that consistently queues the callback after all DOM 22444// events triggered in the same loop is by using MessageChannel. 22445/* istanbul ignore if */ 22446if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { 22447 macroTimerFunc = function () { 22448 setImmediate(flushCallbacks); 22449 }; 22450} else if (typeof MessageChannel !== 'undefined' && ( 22451 isNative(MessageChannel) || 22452 // PhantomJS 22453 MessageChannel.toString() === '[object MessageChannelConstructor]' 22454)) { 22455 var channel = new MessageChannel(); 22456 var port = channel.port2; 22457 channel.port1.onmessage = flushCallbacks; 22458 macroTimerFunc = function () { 22459 port.postMessage(1); 22460 }; 22461} else { 22462 /* istanbul ignore next */
vendor: 8,948 bytes, lines 22463-22821
22463 macroTimerFunc = function () { 22464 setTimeout(flushCallbacks, 0); 22465 }; 22466} 22467 22468// Determine MicroTask defer implementation. 22469/* istanbul ignore next, $flow-disable-line */ 22470if (typeof Promise !== 'undefined' && isNative(Promise)) { 22471 var p = Promise.resolve(); 22472 microTimerFunc = function () { 22473 p.then(flushCallbacks); 22474 // in problematic UIWebViews, Promise.then doesn't completely break, but 22475 // it can get stuck in a weird state where callbacks are pushed into the 22476 // microtask queue but the queue isn't being flushed, until the browser 22477 // needs to do some other work, e.g. handle a timer. Therefore we can 22478 // "force" the microtask queue to be flushed by adding an empty timer. 22479 if (isIOS) { setTimeout(noop); } 22480 }; 22481} else { 22482 // fallback to macro 22483 microTimerFunc = macroTimerFunc; 22484} 22485 22486/** 22487 * Wrap a function so that if any code inside triggers state change, 22488 * the changes are queued using a Task instead of a MicroTask. 22489 */ 22490function withMacroTask (fn) { 22491 return fn._withTask || (fn._withTask = function () { 22492 useMacroTask = true; 22493 var res = fn.apply(null, arguments); 22494 useMacroTask = false; 22495 return res 22496 }) 22497} 22498 22499function nextTick (cb, ctx) { 22500 var _resolve; 22501 callbacks.push(function () { 22502 if (cb) { 22503 try { 22504 cb.call(ctx); 22505 } catch (e) { 22506 handleError(e, ctx, 'nextTick'); 22507 } 22508 } else if (_resolve) { 22509 _resolve(ctx); 22510 } 22511 }); 22512 if (!pending) { 22513 pending = true; 22514 if (useMacroTask) { 22515 macroTimerFunc(); 22516 } else { 22517 microTimerFunc(); 22518 } 22519 } 22520 // $flow-disable-line 22521 if (!cb && typeof Promise !== 'undefined') { 22522 return new Promise(function (resolve) { 22523 _resolve = resolve; 22524 }) 22525 } 22526} 22527 22528/* */ 22529 22530var mark; 22531var measure; 22532 22533{ 22534 var perf = inBrowser && window.performance; 22535 /* istanbul ignore if */ 22536 if ( 22537 perf && 22538 perf.mark && 22539 perf.measure && 22540 perf.clearMarks && 22541 perf.clearMeasures 22542 ) { 22543 mark = function (tag) { return perf.mark(tag); }; 22544 measure = function (name, startTag, endTag) { 22545 perf.measure(name, startTag, endTag); 22546 perf.clearMarks(startTag); 22547 perf.clearMarks(endTag); 22548 perf.clearMeasures(name); 22549 }; 22550 } 22551} 22552 22553/* not type checking this file because flow doesn't play well with Proxy */ 22554 22555var initProxy; 22556 22557{ 22558 var allowedGlobals = makeMap( 22559 'Infinity,undefined,NaN,isFinite,isNaN,' + 22560 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 22561 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + 22562 'require' // for Webpack/Browserify 22563 ); 22564 22565 var warnNonPresent = function (target, key) { 22566 warn( 22567 "Property or method \"" + key + "\" is not defined on the instance but " + 22568 'referenced during render. Make sure that this property is reactive, ' + 22569 'either in the data option, or for class-based components, by ' + 22570 'initializing the property. ' + 22571 'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', 22572 target 22573 ); 22574 }; 22575 22576 var hasProxy = 22577 typeof Proxy !== 'undefined' && 22578 Proxy.toString().match(/native code/); 22579 22580 if (hasProxy) { 22581 var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); 22582 config.keyCodes = new Proxy(config.keyCodes, { 22583 set: function set (target, key, value) { 22584 if (isBuiltInModifier(key)) { 22585 warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key)); 22586 return false 22587 } else { 22588 target[key] = value; 22589 return true 22590 } 22591 } 22592 }); 22593 } 22594 22595 var hasHandler = { 22596 has: function has (target, key) { 22597 var has = key in target; 22598 var isAllowed = allowedGlobals(key) || key.charAt(0) === '_'; 22599 if (!has && !isAllowed) { 22600 warnNonPresent(target, key); 22601 } 22602 return has || !isAllowed 22603 } 22604 }; 22605 22606 var getHandler = { 22607 get: function get (target, key) { 22608 if (typeof key === 'string' && !(key in target)) { 22609 warnNonPresent(target, key); 22610 } 22611 return target[key] 22612 } 22613 }; 22614 22615 initProxy = function initProxy (vm) { 22616 if (hasProxy) { 22617 // determine which proxy handler to use 22618 var options = vm.$options; 22619 var handlers = options.render && options.render._withStripped 22620 ? getHandler 22621 : hasHandler; 22622 vm._renderProxy = new Proxy(vm, handlers); 22623 } else { 22624 vm._renderProxy = vm; 22625 } 22626 }; 22627} 22628 22629/* */ 22630 22631var seenObjects = new _Set(); 22632 22633/** 22634 * Recursively traverse an object to evoke all converted 22635 * getters, so that every nested property inside the object 22636 * is collected as a "deep" dependency. 22637 */ 22638function traverse (val) { 22639 _traverse(val, seenObjects); 22640 seenObjects.clear(); 22641} 22642 22643function _traverse (val, seen) { 22644 var i, keys; 22645 var isA = Array.isArray(val); 22646 if ((!isA && !isObject(val)) || Object.isFrozen(val)) { 22647 return 22648 } 22649 if (val.__ob__) { 22650 var depId = val.__ob__.dep.id; 22651 if (seen.has(depId)) { 22652 return 22653 } 22654 seen.add(depId); 22655 } 22656 if (isA) { 22657 i = val.length; 22658 while (i--) { _traverse(val[i], seen); } 22659 } else { 22660 keys = Object.keys(val); 22661 i = keys.length; 22662 while (i--) { _traverse(val[keys[i]], seen); } 22663 } 22664} 22665 22666/* */ 22667 22668var normalizeEvent = cached(function (name) { 22669 var passive = name.charAt(0) === '&'; 22670 name = passive ? name.slice(1) : name; 22671 var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first 22672 name = once$$1 ? name.slice(1) : name; 22673 var capture = name.charAt(0) === '!'; 22674 name = capture ? name.slice(1) : name; 22675 return { 22676 name: name, 22677 once: once$$1, 22678 capture: capture, 22679 passive: passive 22680 } 22681}); 22682 22683function createFnInvoker (fns) { 22684 function invoker () { 22685 var arguments$1 = arguments; 22686 22687 var fns = invoker.fns; 22688 if (Array.isArray(fns)) { 22689 var cloned = fns.slice(); 22690 for (var i = 0; i < cloned.length; i++) { 22691 cloned[i].apply(null, arguments$1); 22692 } 22693 } else { 22694 // return handler return value for single handlers 22695 return fns.apply(null, arguments) 22696 } 22697 } 22698 invoker.fns = fns; 22699 return invoker 22700} 22701 22702function updateListeners ( 22703 on, 22704 oldOn, 22705 add, 22706 remove$$1, 22707 vm 22708) { 22709 var name, cur, old, event; 22710 for (name in on) { 22711 cur = on[name]; 22712 old = oldOn[name]; 22713 event = normalizeEvent(name); 22714 if (isUndef(cur)) { 22715 "development" !== 'production' && warn( 22716 "Invalid handler for event \"" + (event.name) + "\": got " + String(cur), 22717 vm 22718 ); 22719 } else if (isUndef(old)) { 22720 if (isUndef(cur.fns)) { 22721 cur = on[name] = createFnInvoker(cur); 22722 } 22723 add(event.name, cur, event.once, event.capture, event.passive); 22724 } else if (cur !== old) { 22725 old.fns = cur; 22726 on[name] = old; 22727 } 22728 } 22729 for (name in oldOn) { 22730 if (isUndef(on[name])) { 22731 event = normalizeEvent(name); 22732 remove$$1(event.name, oldOn[name], event.capture); 22733 } 22734 } 22735} 22736 22737/* */ 22738 22739function mergeVNodeHook (def, hookKey, hook) { 22740 if (def instanceof VNode) { 22741 def = def.data.hook || (def.data.hook = {}); 22742 } 22743 var invoker; 22744 var oldHook = def[hookKey]; 22745 22746 function wrappedHook () { 22747 hook.apply(this, arguments); 22748 // important: remove merged hook to ensure it's called only once 22749 // and prevent memory leak 22750 remove(invoker.fns, wrappedHook); 22751 } 22752 22753 if (isUndef(oldHook)) { 22754 // no existing hook 22755 invoker = createFnInvoker([wrappedHook]); 22756 } else { 22757 /* istanbul ignore if */ 22758 if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { 22759 // already a merged invoker 22760 invoker = oldHook; 22761 invoker.fns.push(wrappedHook); 22762 } else { 22763 // existing plain hook 22764 invoker = createFnInvoker([oldHook, wrappedHook]); 22765 } 22766 } 22767 22768 invoker.merged = true; 22769 def[hookKey] = invoker; 22770} 22771 22772/* */ 22773 22774function extractPropsFromVNodeData ( 22775 data, 22776 Ctor, 22777 tag 22778) { 22779 // we are only extracting raw values here. 22780 // validation and default values are handled in the child 22781 // component itself. 22782 var propOptions = Ctor.options.props; 22783 if (isUndef(propOptions)) { 22784 return 22785 } 22786 var res = {}; 22787 var attrs = data.attrs; 22788 var props = data.props; 22789 if (isDef(attrs) || isDef(props)) { 22790 for (var key in propOptions) { 22791 var altKey = hyphenate(key); 22792 { 22793 var keyInLowerCase = key.toLowerCase(); 22794 if ( 22795 key !== keyInLowerCase && 22796 attrs && hasOwn(attrs, keyInLowerCase) 22797 ) { 22798 tip( 22799 "Prop \"" + keyInLowerCase + "\" is passed to component " + 22800 (formatComponentName(tag || Ctor)) + ", but the declared prop name is" + 22801 " \"" + key + "\". " + 22802 "Note that HTML attributes are case-insensitive and camelCased " + 22803 "props need to use their kebab-case equivalents when using in-DOM " + 22804 "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"." 22805 ); 22806 } 22807 } 22808 checkProp(res, props, key, altKey, true) || 22809 checkProp(res, attrs, key, altKey, false); 22810 } 22811 } 22812 return res 22813} 22814 22815function checkProp ( 22816 res, 22817 hash, 22818 key, 22819 altKey, 22820 preserve 22821) {
vendor: 5,221 bytes, lines 22822-23006
22822 if (isDef(hash)) { 22823 if (hasOwn(hash, key)) { 22824 res[key] = hash[key]; 22825 if (!preserve) { 22826 delete hash[key]; 22827 } 22828 return true 22829 } else if (hasOwn(hash, altKey)) { 22830 res[key] = hash[altKey]; 22831 if (!preserve) { 22832 delete hash[altKey]; 22833 } 22834 return true 22835 } 22836 } 22837 return false 22838} 22839 22840/* */ 22841 22842// The template compiler attempts to minimize the need for normalization by 22843// statically analyzing the template at compile time. 22844// 22845// For plain HTML markup, normalization can be completely skipped because the 22846// generated render function is guaranteed to return Array<VNode>. There are 22847// two cases where extra normalization is needed: 22848 22849// 1. When the children contains components - because a functional component 22850// may return an Array instead of a single root. In this case, just a simple 22851// normalization is needed - if any child is an Array, we flatten the whole 22852// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 22853// because functional components already normalize their own children. 22854function simpleNormalizeChildren (children) { 22855 for (var i = 0; i < children.length; i++) { 22856 if (Array.isArray(children[i])) { 22857 return Array.prototype.concat.apply([], children) 22858 } 22859 } 22860 return children 22861} 22862 22863// 2. When the children contains constructs that always generated nested Arrays, 22864// e.g. <template>, <slot>, v-for, or when the children is provided by user 22865// with hand-written render functions / JSX. In such cases a full normalization 22866// is needed to cater to all possible types of children values. 22867function normalizeChildren (children) { 22868 return isPrimitive(children) 22869 ? [createTextVNode(children)] 22870 : Array.isArray(children) 22871 ? normalizeArrayChildren(children) 22872 : undefined 22873} 22874 22875function isTextNode (node) { 22876 return isDef(node) && isDef(node.text) && isFalse(node.isComment) 22877} 22878 22879function normalizeArrayChildren (children, nestedIndex) { 22880 var res = []; 22881 var i, c, lastIndex, last; 22882 for (i = 0; i < children.length; i++) { 22883 c = children[i]; 22884 if (isUndef(c) || typeof c === 'boolean') { continue } 22885 lastIndex = res.length - 1; 22886 last = res[lastIndex]; 22887 // nested 22888 if (Array.isArray(c)) { 22889 if (c.length > 0) { 22890 c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)); 22891 // merge adjacent text nodes 22892 if (isTextNode(c[0]) && isTextNode(last)) { 22893 res[lastIndex] = createTextVNode(last.text + (c[0]).text); 22894 c.shift(); 22895 } 22896 res.push.apply(res, c); 22897 } 22898 } else if (isPrimitive(c)) { 22899 if (isTextNode(last)) { 22900 // merge adjacent text nodes 22901 // this is necessary for SSR hydration because text nodes are 22902 // essentially merged when rendered to HTML strings 22903 res[lastIndex] = createTextVNode(last.text + c); 22904 } else if (c !== '') { 22905 // convert primitive to vnode 22906 res.push(createTextVNode(c)); 22907 } 22908 } else { 22909 if (isTextNode(c) && isTextNode(last)) { 22910 // merge adjacent text nodes 22911 res[lastIndex] = createTextVNode(last.text + c.text); 22912 } else { 22913 // default key for nested array children (likely generated by v-for) 22914 if (isTrue(children._isVList) && 22915 isDef(c.tag) && 22916 isUndef(c.key) && 22917 isDef(nestedIndex)) { 22918 c.key = "__vlist" + nestedIndex + "_" + i + "__"; 22919 } 22920 res.push(c); 22921 } 22922 } 22923 } 22924 return res 22925} 22926 22927/* */ 22928 22929function ensureCtor (comp, base) { 22930 if ( 22931 comp.__esModule || 22932 (hasSymbol && comp[Symbol.toStringTag] === 'Module') 22933 ) { 22934 comp = comp.default; 22935 } 22936 return isObject(comp) 22937 ? base.extend(comp) 22938 : comp 22939} 22940 22941function createAsyncPlaceholder ( 22942 factory, 22943 data, 22944 context, 22945 children, 22946 tag 22947) { 22948 var node = createEmptyVNode(); 22949 node.asyncFactory = factory; 22950 node.asyncMeta = { data: data, context: context, children: children, tag: tag }; 22951 return node 22952} 22953 22954function resolveAsyncComponent ( 22955 factory, 22956 baseCtor, 22957 context 22958) { 22959 if (isTrue(factory.error) && isDef(factory.errorComp)) { 22960 return factory.errorComp 22961 } 22962 22963 if (isDef(factory.resolved)) { 22964 return factory.resolved 22965 } 22966 22967 if (isTrue(factory.loading) && isDef(factory.loadingComp)) { 22968 return factory.loadingComp 22969 } 22970 22971 if (isDef(factory.contexts)) { 22972 // already pending 22973 factory.contexts.push(context); 22974 } else { 22975 var contexts = factory.contexts = [context]; 22976 var sync = true; 22977 22978 var forceRender = function () { 22979 for (var i = 0, l = contexts.length; i < l; i++) { 22980 contexts[i].$forceUpdate(); 22981 } 22982 }; 22983 22984 var resolve = once(function (res) { 22985 // cache resolved 22986 factory.resolved = ensureCtor(res, baseCtor); 22987 // invoke callbacks only if this is not a synchronous resolve 22988 // (async resolves are shimmed as synchronous during SSR) 22989 if (!sync) { 22990 forceRender(); 22991 } 22992 }); 22993 22994 var reject = once(function (reason) { 22995 "development" !== 'production' && warn( 22996 "Failed to resolve async component: " + (String(factory)) + 22997 (reason ? ("\nReason: " + reason) : '') 22998 ); 22999 if (isDef(factory.errorComp)) { 23000 factory.error = true; 23001 forceRender(); 23002 } 23003 }); 23004 23005 var res = factory(resolve, reject); 23006
23007 if (isObject(res)) { 23008 if (typeof res.then === 'function') { 23009 // () => Promise 23010 if (isUndef(factory.resolved)) { 23011 res.then(resolve, reject); 23012 } 23013 } else if (isDef(res.component) && typeof res.component.then === 'function') { 23014 res.component.then(resolve, reject); 23015 23016 if (isDef(res.error)) { 23017 factory.errorComp = ensureCtor(res.error, baseCtor); 23018 } 23019 23020 if (isDef(res.loading)) { 23021 factory.loadingComp = ensureCtor(res.loading, baseCtor); 23022 if (res.delay === 0) { 23023 factory.loading = true; 23024 } else { 23025 setTimeout(function () { 23026 if (isUndef(factory.resolved) && isUndef(factory.error)) { 23027 factory.loading = true; 23028 forceRender(); 23029 } 23030 }, res.delay || 200); 23031 } 23032 } 23033 23034 if (isDef(res.timeout)) { 23035 setTimeout(function () { 23036 if (isUndef(factory.resolved)) { 23037 reject( 23038 "timeout (" + (res.timeout) + "ms)" 23039 ); 23040 } 23041 }, res.timeout); 23042 } 23043 } 23044 } 23045 23046 sync = false; 23047 // return in case resolved synchronously 23048 return factory.loading 23049 ? factory.loadingComp 23050 : factory.resolved 23051 } 23052} 23053 23054/* */ 23055 23056function isAsyncPlaceholder (node) { 23057 return node.isComment && node.asyncFactory 23058} 23059 23060/* */ 23061 23062function getFirstComponentChild (children) { 23063 if (Array.isArray(children)) { 23064 for (var i = 0; i < children.length; i++) { 23065 var c = children[i]; 23066 if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { 23067 return c 23068 } 23069 } 23070 } 23071} 23072 23073/* */ 23074 23075/* */ 23076 23077function initEvents (vm) { 23078 vm._events = Object.create(null); 23079 vm._hasHookEvent = false; 23080 // init parent attached events 23081 var listeners = vm.$options._parentListeners; 23082 if (listeners) { 23083 updateComponentListeners(vm, listeners); 23084 } 23085} 23086 23087var target; 23088 23089function add (event, fn, once) { 23090 if (once) { 23091 target.$once(event, fn); 23092 } else { 23093 target.$on(event, fn); 23094 } 23095} 23096 23097function remove$1 (event, fn) { 23098 target.$off(event, fn); 23099} 23100 23101function updateComponentListeners ( 23102 vm, 23103 listeners, 23104 oldListeners 23105) { 23106 target = vm; 23107 updateListeners(listeners, oldListeners || {}, add, remove$1, vm); 23108 target = undefined; 23109} 23110 23111function eventsMixin (Vue) { 23112 var hookRE = /^hook:/; 23113 Vue.prototype.$on = function (event, fn) { 23114 var this$1 = this; 23115 23116 var vm = this; 23117 if (Array.isArray(event)) { 23118 for (var i = 0, l = event.length; i < l; i++) { 23119 this$1.$on(event[i], fn); 23120 } 23121 } else { 23122 (vm._events[event] || (vm._events[event] = [])).push(fn); 23123 // optimize hook:event cost by using a boolean flag marked at registration 23124 // instead of a hash lookup 23125 if (hookRE.test(event)) { 23126 vm._hasHookEvent = true; 23127 } 23128 } 23129 return vm 23130 }; 23131 23132 Vue.prototype.$once = function (event, fn) { 23133 var vm = this; 23134 function on () { 23135 vm.$off(event, on); 23136 fn.apply(vm, arguments); 23137 } 23138 on.fn = fn; 23139 vm.$on(event, on); 23140 return vm 23141 }; 23142 23143 Vue.prototype.$off = function (event, fn) { 23144 var this$1 = this; 23145 23146 var vm = this; 23147 // all 23148 if (!arguments.length) { 23149 vm._events = Object.create(null); 23150 return vm 23151 } 23152 // array of events 23153 if (Array.isArray(event)) { 23154 for (var i = 0, l = event.length; i < l; i++) { 23155 this$1.$off(event[i], fn); 23156 } 23157 return vm 23158 } 23159 // specific event 23160 var cbs = vm._events[event]; 23161 if (!cbs) { 23162 return vm 23163 } 23164 if (!fn) { 23165 vm._events[event] = null; 23166 return vm 23167 } 23168 if (fn) { 23169 // specific handler 23170 var cb; 23171 var i$1 = cbs.length; 23172 while (i$1--) { 23173 cb = cbs[i$1]; 23174 if (cb === fn || cb.fn === fn) { 23175 cbs.splice(i$1, 1); 23176 break 23177 } 23178 } 23179 } 23180 return vm 23181 }; 23182 23183 Vue.prototype.$emit = function (event) { 23184 var vm = this; 23185 { 23186 var lowerCaseEvent = event.toLowerCase(); 23187 if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) { 23188 tip( 23189 "Event \"" + lowerCaseEvent + "\" is emitted in component " + 23190 (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
vendor: 24,705 bytes, lines 23191-24150
23191 "Note that HTML attributes are case-insensitive and you cannot use " + 23192 "v-on to listen to camelCase events when using in-DOM templates. " + 23193 "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"." 23194 ); 23195 } 23196 } 23197 var cbs = vm._events[event]; 23198 if (cbs) { 23199 cbs = cbs.length > 1 ? toArray(cbs) : cbs; 23200 var args = toArray(arguments, 1); 23201 for (var i = 0, l = cbs.length; i < l; i++) { 23202 try { 23203 cbs[i].apply(vm, args); 23204 } catch (e) { 23205 handleError(e, vm, ("event handler for \"" + event + "\"")); 23206 } 23207 } 23208 } 23209 return vm 23210 }; 23211} 23212 23213/* */ 23214 23215/** 23216 * Runtime helper for resolving raw children VNodes into a slot object. 23217 */ 23218function resolveSlots ( 23219 children, 23220 context 23221) { 23222 var slots = {}; 23223 if (!children) { 23224 return slots 23225 } 23226 for (var i = 0, l = children.length; i < l; i++) { 23227 var child = children[i]; 23228 var data = child.data; 23229 // remove slot attribute if the node is resolved as a Vue slot node 23230 if (data && data.attrs && data.attrs.slot) { 23231 delete data.attrs.slot; 23232 } 23233 // named slots should only be respected if the vnode was rendered in the 23234 // same context. 23235 if ((child.context === context || child.functionalContext === context) && 23236 data && data.slot != null 23237 ) { 23238 var name = child.data.slot; 23239 var slot = (slots[name] || (slots[name] = [])); 23240 if (child.tag === 'template') { 23241 slot.push.apply(slot, child.children); 23242 } else { 23243 slot.push(child); 23244 } 23245 } else { 23246 (slots.default || (slots.default = [])).push(child); 23247 } 23248 } 23249 // ignore slots that contains only whitespace 23250 for (var name$1 in slots) { 23251 if (slots[name$1].every(isWhitespace)) { 23252 delete slots[name$1]; 23253 } 23254 } 23255 return slots 23256} 23257 23258function isWhitespace (node) { 23259 return (node.isComment && !node.asyncFactory) || node.text === ' ' 23260} 23261 23262function resolveScopedSlots ( 23263 fns, // see flow/vnode 23264 res 23265) { 23266 res = res || {}; 23267 for (var i = 0; i < fns.length; i++) { 23268 if (Array.isArray(fns[i])) { 23269 resolveScopedSlots(fns[i], res); 23270 } else { 23271 res[fns[i].key] = fns[i].fn; 23272 } 23273 } 23274 return res 23275} 23276 23277/* */ 23278 23279var activeInstance = null; 23280var isUpdatingChildComponent = false; 23281 23282function initLifecycle (vm) { 23283 var options = vm.$options; 23284 23285 // locate first non-abstract parent 23286 var parent = options.parent; 23287 if (parent && !options.abstract) { 23288 while (parent.$options.abstract && parent.$parent) { 23289 parent = parent.$parent; 23290 } 23291 parent.$children.push(vm); 23292 } 23293 23294 vm.$parent = parent; 23295 vm.$root = parent ? parent.$root : vm; 23296 23297 vm.$children = []; 23298 vm.$refs = {}; 23299 23300 vm._watcher = null; 23301 vm._inactive = null; 23302 vm._directInactive = false; 23303 vm._isMounted = false; 23304 vm._isDestroyed = false; 23305 vm._isBeingDestroyed = false; 23306} 23307 23308function lifecycleMixin (Vue) { 23309 Vue.prototype._update = function (vnode, hydrating) { 23310 var vm = this; 23311 if (vm._isMounted) { 23312 callHook(vm, 'beforeUpdate'); 23313 } 23314 var prevEl = vm.$el; 23315 var prevVnode = vm._vnode; 23316 var prevActiveInstance = activeInstance; 23317 activeInstance = vm; 23318 vm._vnode = vnode; 23319 // Vue.prototype.__patch__ is injected in entry points 23320 // based on the rendering backend used. 23321 if (!prevVnode) { 23322 // initial render 23323 vm.$el = vm.__patch__( 23324 vm.$el, vnode, hydrating, false /* removeOnly */, 23325 vm.$options._parentElm, 23326 vm.$options._refElm 23327 ); 23328 // no need for the ref nodes after initial patch 23329 // this prevents keeping a detached DOM tree in memory (#5851) 23330 vm.$options._parentElm = vm.$options._refElm = null; 23331 } else { 23332 // updates 23333 vm.$el = vm.__patch__(prevVnode, vnode); 23334 } 23335 activeInstance = prevActiveInstance; 23336 // update __vue__ reference 23337 if (prevEl) { 23338 prevEl.__vue__ = null; 23339 } 23340 if (vm.$el) { 23341 vm.$el.__vue__ = vm; 23342 } 23343 // if parent is an HOC, update its $el as well 23344 if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { 23345 vm.$parent.$el = vm.$el; 23346 } 23347 // updated hook is called by the scheduler to ensure that children are 23348 // updated in a parent's updated hook. 23349 }; 23350 23351 Vue.prototype.$forceUpdate = function () { 23352 var vm = this; 23353 if (vm._watcher) { 23354 vm._watcher.update(); 23355 } 23356 }; 23357 23358 Vue.prototype.$destroy = function () { 23359 var vm = this; 23360 if (vm._isBeingDestroyed) { 23361 return 23362 } 23363 callHook(vm, 'beforeDestroy'); 23364 vm._isBeingDestroyed = true; 23365 // remove self from parent 23366 var parent = vm.$parent; 23367 if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { 23368 remove(parent.$children, vm); 23369 } 23370 // teardown watchers 23371 if (vm._watcher) { 23372 vm._watcher.teardown(); 23373 } 23374 var i = vm._watchers.length; 23375 while (i--) { 23376 vm._watchers[i].teardown(); 23377 } 23378 // remove reference from data ob 23379 // frozen object may not have observer. 23380 if (vm._data.__ob__) { 23381 vm._data.__ob__.vmCount--; 23382 } 23383 // call the last hook... 23384 vm._isDestroyed = true; 23385 // invoke destroy hooks on current rendered tree 23386 vm.__patch__(vm._vnode, null); 23387 // fire destroyed hook 23388 callHook(vm, 'destroyed'); 23389 // turn off all instance listeners. 23390 vm.$off(); 23391 // remove __vue__ reference 23392 if (vm.$el) { 23393 vm.$el.__vue__ = null; 23394 } 23395 // release circular reference (#6759) 23396 if (vm.$vnode) { 23397 vm.$vnode.parent = null; 23398 } 23399 }; 23400} 23401 23402function mountComponent ( 23403 vm, 23404 el, 23405 hydrating 23406) { 23407 vm.$el = el; 23408 if (!vm.$options.render) { 23409 vm.$options.render = createEmptyVNode; 23410 { 23411 /* istanbul ignore if */ 23412 if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') || 23413 vm.$options.el || el) { 23414 warn( 23415 'You are using the runtime-only build of Vue where the template ' + 23416 'compiler is not available. Either pre-compile the templates into ' + 23417 'render functions, or use the compiler-included build.', 23418 vm 23419 ); 23420 } else { 23421 warn( 23422 'Failed to mount component: template or render function not defined.', 23423 vm 23424 ); 23425 } 23426 } 23427 } 23428 callHook(vm, 'beforeMount'); 23429 23430 var updateComponent; 23431 /* istanbul ignore if */ 23432 if ("development" !== 'production' && config.performance && mark) { 23433 updateComponent = function () { 23434 var name = vm._name; 23435 var id = vm._uid; 23436 var startTag = "vue-perf-start:" + id; 23437 var endTag = "vue-perf-end:" + id; 23438 23439 mark(startTag); 23440 var vnode = vm._render(); 23441 mark(endTag); 23442 measure(("vue " + name + " render"), startTag, endTag); 23443 23444 mark(startTag); 23445 vm._update(vnode, hydrating); 23446 mark(endTag); 23447 measure(("vue " + name + " patch"), startTag, endTag); 23448 }; 23449 } else { 23450 updateComponent = function () { 23451 vm._update(vm._render(), hydrating); 23452 }; 23453 } 23454 23455 vm._watcher = new Watcher(vm, updateComponent, noop); 23456 hydrating = false; 23457 23458 // manually mounted instance, call mounted on self 23459 // mounted is called for render-created child components in its inserted hook 23460 if (vm.$vnode == null) { 23461 vm._isMounted = true; 23462 callHook(vm, 'mounted'); 23463 } 23464 return vm 23465} 23466 23467function updateChildComponent ( 23468 vm, 23469 propsData, 23470 listeners, 23471 parentVnode, 23472 renderChildren 23473) { 23474 { 23475 isUpdatingChildComponent = true; 23476 } 23477 23478 // determine whether component has slot children 23479 // we need to do this before overwriting $options._renderChildren 23480 var hasChildren = !!( 23481 renderChildren || // has new static slots 23482 vm.$options._renderChildren || // has old static slots 23483 parentVnode.data.scopedSlots || // has new scoped slots 23484 vm.$scopedSlots !== emptyObject // has old scoped slots 23485 ); 23486 23487 vm.$options._parentVnode = parentVnode; 23488 vm.$vnode = parentVnode; // update vm's placeholder node without re-render 23489 23490 if (vm._vnode) { // update child tree's parent 23491 vm._vnode.parent = parentVnode; 23492 } 23493 vm.$options._renderChildren = renderChildren; 23494 23495 // update $attrs and $listeners hash 23496 // these are also reactive so they may trigger child update if the child 23497 // used them during render 23498 vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject; 23499 vm.$listeners = listeners || emptyObject; 23500 23501 // update props 23502 if (propsData && vm.$options.props) { 23503 observerState.shouldConvert = false; 23504 var props = vm._props; 23505 var propKeys = vm.$options._propKeys || []; 23506 for (var i = 0; i < propKeys.length; i++) { 23507 var key = propKeys[i]; 23508 props[key] = validateProp(key, vm.$options.props, propsData, vm); 23509 } 23510 observerState.shouldConvert = true; 23511 // keep a copy of raw propsData 23512 vm.$options.propsData = propsData; 23513 } 23514 23515 // update listeners 23516 if (listeners) { 23517 var oldListeners = vm.$options._parentListeners; 23518 vm.$options._parentListeners = listeners; 23519 updateComponentListeners(vm, listeners, oldListeners); 23520 } 23521 // resolve slots + force update if has children 23522 if (hasChildren) { 23523 vm.$slots = resolveSlots(renderChildren, parentVnode.context); 23524 vm.$forceUpdate(); 23525 } 23526 23527 { 23528 isUpdatingChildComponent = false; 23529 } 23530} 23531 23532function isInInactiveTree (vm) { 23533 while (vm && (vm = vm.$parent)) { 23534 if (vm._inactive) { return true } 23535 } 23536 return false 23537} 23538 23539function activateChildComponent (vm, direct) { 23540 if (direct) { 23541 vm._directInactive = false; 23542 if (isInInactiveTree(vm)) { 23543 return 23544 } 23545 } else if (vm._directInactive) { 23546 return 23547 } 23548 if (vm._inactive || vm._inactive === null) { 23549 vm._inactive = false; 23550 for (var i = 0; i < vm.$children.length; i++) { 23551 activateChildComponent(vm.$children[i]); 23552 } 23553 callHook(vm, 'activated'); 23554 } 23555} 23556 23557function deactivateChildComponent (vm, direct) { 23558 if (direct) { 23559 vm._directInactive = true; 23560 if (isInInactiveTree(vm)) { 23561 return 23562 } 23563 } 23564 if (!vm._inactive) { 23565 vm._inactive = true; 23566 for (var i = 0; i < vm.$children.length; i++) { 23567 deactivateChildComponent(vm.$children[i]); 23568 } 23569 callHook(vm, 'deactivated'); 23570 } 23571} 23572 23573function callHook (vm, hook) { 23574 var handlers = vm.$options[hook]; 23575 if (handlers) { 23576 for (var i = 0, j = handlers.length; i < j; i++) { 23577 try { 23578 handlers[i].call(vm); 23579 } catch (e) { 23580 handleError(e, vm, (hook + " hook")); 23581 } 23582 } 23583 } 23584 if (vm._hasHookEvent) { 23585 vm.$emit('hook:' + hook); 23586 } 23587} 23588 23589/* */ 23590 23591 23592var MAX_UPDATE_COUNT = 100; 23593 23594var queue = []; 23595var activatedChildren = []; 23596var has = {}; 23597var circular = {}; 23598var waiting = false; 23599var flushing = false; 23600var index = 0; 23601 23602/** 23603 * Reset the scheduler's state. 23604 */ 23605function resetSchedulerState () { 23606 index = queue.length = activatedChildren.length = 0; 23607 has = {}; 23608 { 23609 circular = {}; 23610 } 23611 waiting = flushing = false; 23612} 23613 23614/** 23615 * Flush both queues and run the watchers. 23616 */ 23617function flushSchedulerQueue () { 23618 flushing = true; 23619 var watcher, id; 23620 23621 // Sort queue before flush. 23622 // This ensures that: 23623 // 1. Components are updated from parent to child. (because parent is always 23624 // created before the child) 23625 // 2. A component's user watchers are run before its render watcher (because 23626 // user watchers are created before the render watcher) 23627 // 3. If a component is destroyed during a parent component's watcher run, 23628 // its watchers can be skipped. 23629 queue.sort(function (a, b) { return a.id - b.id; }); 23630 23631 // do not cache length because more watchers might be pushed 23632 // as we run existing watchers 23633 for (index = 0; index < queue.length; index++) { 23634 watcher = queue[index]; 23635 id = watcher.id; 23636 has[id] = null; 23637 watcher.run(); 23638 // in dev build, check and stop circular updates. 23639 if ("development" !== 'production' && has[id] != null) { 23640 circular[id] = (circular[id] || 0) + 1; 23641 if (circular[id] > MAX_UPDATE_COUNT) { 23642 warn( 23643 'You may have an infinite update loop ' + ( 23644 watcher.user 23645 ? ("in watcher with expression \"" + (watcher.expression) + "\"") 23646 : "in a component render function." 23647 ), 23648 watcher.vm 23649 ); 23650 break 23651 } 23652 } 23653 } 23654 23655 // keep copies of post queues before resetting state 23656 var activatedQueue = activatedChildren.slice(); 23657 var updatedQueue = queue.slice(); 23658 23659 resetSchedulerState(); 23660 23661 // call component updated and activated hooks 23662 callActivatedHooks(activatedQueue); 23663 callUpdatedHooks(updatedQueue); 23664 23665 // devtool hook 23666 /* istanbul ignore if */ 23667 if (devtools && config.devtools) { 23668 devtools.emit('flush'); 23669 } 23670} 23671 23672function callUpdatedHooks (queue) { 23673 var i = queue.length; 23674 while (i--) { 23675 var watcher = queue[i]; 23676 var vm = watcher.vm; 23677 if (vm._watcher === watcher && vm._isMounted) { 23678 callHook(vm, 'updated'); 23679 } 23680 } 23681} 23682 23683/** 23684 * Queue a kept-alive component that was activated during patch. 23685 * The queue will be processed after the entire tree has been patched. 23686 */ 23687function queueActivatedComponent (vm) { 23688 // setting _inactive to false here so that a render function can 23689 // rely on checking whether it's in an inactive tree (e.g. router-view) 23690 vm._inactive = false; 23691 activatedChildren.push(vm); 23692} 23693 23694function callActivatedHooks (queue) { 23695 for (var i = 0; i < queue.length; i++) { 23696 queue[i]._inactive = true; 23697 activateChildComponent(queue[i], true /* true */); 23698 } 23699} 23700 23701/** 23702 * Push a watcher into the watcher queue. 23703 * Jobs with duplicate IDs will be skipped unless it's 23704 * pushed when the queue is being flushed. 23705 */ 23706function queueWatcher (watcher) { 23707 var id = watcher.id; 23708 if (has[id] == null) { 23709 has[id] = true; 23710 if (!flushing) { 23711 queue.push(watcher); 23712 } else { 23713 // if already flushing, splice the watcher based on its id 23714 // if already past its id, it will be run next immediately. 23715 var i = queue.length - 1; 23716 while (i > index && queue[i].id > watcher.id) { 23717 i--; 23718 } 23719 queue.splice(i + 1, 0, watcher); 23720 } 23721 // queue the flush 23722 if (!waiting) { 23723 waiting = true; 23724 nextTick(flushSchedulerQueue); 23725 } 23726 } 23727} 23728 23729/* */ 23730 23731var uid$2 = 0; 23732 23733/** 23734 * A watcher parses an expression, collects dependencies, 23735 * and fires callback when the expression value changes. 23736 * This is used for both the $watch() api and directives. 23737 */ 23738var Watcher = function Watcher ( 23739 vm, 23740 expOrFn, 23741 cb, 23742 options 23743) { 23744 this.vm = vm; 23745 vm._watchers.push(this); 23746 // options 23747 if (options) { 23748 this.deep = !!options.deep; 23749 this.user = !!options.user; 23750 this.lazy = !!options.lazy; 23751 this.sync = !!options.sync; 23752 } else { 23753 this.deep = this.user = this.lazy = this.sync = false; 23754 } 23755 this.cb = cb; 23756 this.id = ++uid$2; // uid for batching 23757 this.active = true; 23758 this.dirty = this.lazy; // for lazy watchers 23759 this.deps = []; 23760 this.newDeps = []; 23761 this.depIds = new _Set(); 23762 this.newDepIds = new _Set(); 23763 this.expression = expOrFn.toString(); 23764 // parse expression for getter 23765 if (typeof expOrFn === 'function') { 23766 this.getter = expOrFn; 23767 } else { 23768 this.getter = parsePath(expOrFn); 23769 if (!this.getter) { 23770 this.getter = function () {}; 23771 "development" !== 'production' && warn( 23772 "Failed watching path: \"" + expOrFn + "\" " + 23773 'Watcher only accepts simple dot-delimited paths. ' + 23774 'For full control, use a function instead.', 23775 vm 23776 ); 23777 } 23778 } 23779 this.value = this.lazy 23780 ? undefined 23781 : this.get(); 23782}; 23783 23784/** 23785 * Evaluate the getter, and re-collect dependencies. 23786 */ 23787Watcher.prototype.get = function get () { 23788 pushTarget(this); 23789 var value; 23790 var vm = this.vm; 23791 try { 23792 value = this.getter.call(vm, vm); 23793 } catch (e) { 23794 if (this.user) { 23795 handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\"")); 23796 } else { 23797 throw e 23798 } 23799 } finally { 23800 // "touch" every property so they are all tracked as 23801 // dependencies for deep watching 23802 if (this.deep) { 23803 traverse(value); 23804 } 23805 popTarget(); 23806 this.cleanupDeps(); 23807 } 23808 return value 23809}; 23810 23811/** 23812 * Add a dependency to this directive. 23813 */ 23814Watcher.prototype.addDep = function addDep (dep) { 23815 var id = dep.id; 23816 if (!this.newDepIds.has(id)) { 23817 this.newDepIds.add(id); 23818 this.newDeps.push(dep); 23819 if (!this.depIds.has(id)) { 23820 dep.addSub(this); 23821 } 23822 } 23823}; 23824 23825/** 23826 * Clean up for dependency collection. 23827 */ 23828Watcher.prototype.cleanupDeps = function cleanupDeps () { 23829 var this$1 = this; 23830 23831 var i = this.deps.length; 23832 while (i--) { 23833 var dep = this$1.deps[i]; 23834 if (!this$1.newDepIds.has(dep.id)) { 23835 dep.removeSub(this$1); 23836 } 23837 } 23838 var tmp = this.depIds; 23839 this.depIds = this.newDepIds; 23840 this.newDepIds = tmp; 23841 this.newDepIds.clear(); 23842 tmp = this.deps; 23843 this.deps = this.newDeps; 23844 this.newDeps = tmp; 23845 this.newDeps.length = 0; 23846}; 23847 23848/** 23849 * Subscriber interface. 23850 * Will be called when a dependency changes. 23851 */ 23852Watcher.prototype.update = function update () { 23853 /* istanbul ignore else */ 23854 if (this.lazy) { 23855 this.dirty = true; 23856 } else if (this.sync) { 23857 this.run(); 23858 } else { 23859 queueWatcher(this); 23860 } 23861}; 23862 23863/** 23864 * Scheduler job interface. 23865 * Will be called by the scheduler. 23866 */ 23867Watcher.prototype.run = function run () { 23868 if (this.active) { 23869 var value = this.get(); 23870 if ( 23871 value !== this.value || 23872 // Deep watchers and watchers on Object/Arrays should fire even 23873 // when the value is the same, because the value may 23874 // have mutated. 23875 isObject(value) || 23876 this.deep 23877 ) { 23878 // set new value 23879 var oldValue = this.value; 23880 this.value = value; 23881 if (this.user) { 23882 try { 23883 this.cb.call(this.vm, value, oldValue); 23884 } catch (e) { 23885 handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\"")); 23886 } 23887 } else { 23888 this.cb.call(this.vm, value, oldValue); 23889 } 23890 } 23891 } 23892}; 23893 23894/** 23895 * Evaluate the value of the watcher. 23896 * This only gets called for lazy watchers. 23897 */ 23898Watcher.prototype.evaluate = function evaluate () { 23899 this.value = this.get(); 23900 this.dirty = false; 23901}; 23902 23903/** 23904 * Depend on all deps collected by this watcher. 23905 */ 23906Watcher.prototype.depend = function depend () { 23907 var this$1 = this; 23908 23909 var i = this.deps.length; 23910 while (i--) { 23911 this$1.deps[i].depend(); 23912 } 23913}; 23914 23915/** 23916 * Remove self from all dependencies' subscriber list. 23917 */ 23918Watcher.prototype.teardown = function teardown () { 23919 var this$1 = this; 23920 23921 if (this.active) { 23922 // remove self from vm's watcher list 23923 // this is a somewhat expensive operation so we skip it 23924 // if the vm is being destroyed. 23925 if (!this.vm._isBeingDestroyed) { 23926 remove(this.vm._watchers, this); 23927 } 23928 var i = this.deps.length; 23929 while (i--) { 23930 this$1.deps[i].removeSub(this$1); 23931 } 23932 this.active = false; 23933 } 23934}; 23935 23936/* */ 23937 23938var sharedPropertyDefinition = { 23939 enumerable: true, 23940 configurable: true, 23941 get: noop, 23942 set: noop 23943}; 23944 23945function proxy (target, sourceKey, key) { 23946 sharedPropertyDefinition.get = function proxyGetter () { 23947 return this[sourceKey][key] 23948 }; 23949 sharedPropertyDefinition.set = function proxySetter (val) { 23950 this[sourceKey][key] = val; 23951 }; 23952 Object.defineProperty(target, key, sharedPropertyDefinition); 23953} 23954 23955function initState (vm) { 23956 vm._watchers = []; 23957 var opts = vm.$options; 23958 if (opts.props) { initProps(vm, opts.props); } 23959 if (opts.methods) { initMethods(vm, opts.methods); } 23960 if (opts.data) { 23961 initData(vm); 23962 } else { 23963 observe(vm._data = {}, true /* asRootData */); 23964 } 23965 if (opts.computed) { initComputed(vm, opts.computed); } 23966 if (opts.watch && opts.watch !== nativeWatch) { 23967 initWatch(vm, opts.watch); 23968 } 23969} 23970 23971function initProps (vm, propsOptions) { 23972 var propsData = vm.$options.propsData || {}; 23973 var props = vm._props = {}; 23974 // cache prop keys so that future props updates can iterate using Array 23975 // instead of dynamic object key enumeration. 23976 var keys = vm.$options._propKeys = []; 23977 var isRoot = !vm.$parent; 23978 // root instance props should be converted 23979 observerState.shouldConvert = isRoot; 23980 var loop = function ( key ) { 23981 keys.push(key); 23982 var value = validateProp(key, propsOptions, propsData, vm); 23983 /* istanbul ignore else */ 23984 { 23985 var hyphenatedKey = hyphenate(key); 23986 if (isReservedAttribute(hyphenatedKey) || 23987 config.isReservedAttr(hyphenatedKey)) { 23988 warn( 23989 ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), 23990 vm 23991 ); 23992 } 23993 defineReactive(props, key, value, function () { 23994 if (vm.$parent && !isUpdatingChildComponent) { 23995 warn( 23996 "Avoid mutating a prop directly since the value will be " + 23997 "overwritten whenever the parent component re-renders. " + 23998 "Instead, use a data or computed property based on the prop's " + 23999 "value. Prop being mutated: \"" + key + "\"", 24000 vm 24001 ); 24002 } 24003 }); 24004 } 24005 // static props are already proxied on the component's prototype 24006 // during Vue.extend(). We only need to proxy props defined at 24007 // instantiation here. 24008 if (!(key in vm)) { 24009 proxy(vm, "_props", key); 24010 } 24011 }; 24012 24013 for (var key in propsOptions) loop( key ); 24014 observerState.shouldConvert = true; 24015} 24016 24017function initData (vm) { 24018 var data = vm.$options.data; 24019 data = vm._data = typeof data === 'function' 24020 ? getData(data, vm) 24021 : data || {}; 24022 if (!isPlainObject(data)) { 24023 data = {}; 24024 "development" !== 'production' && warn( 24025 'data functions should return an object:\n' + 24026 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', 24027 vm 24028 ); 24029 } 24030 // proxy data on instance 24031 var keys = Object.keys(data); 24032 var props = vm.$options.props; 24033 var methods = vm.$options.methods; 24034 var i = keys.length; 24035 while (i--) { 24036 var key = keys[i]; 24037 { 24038 if (methods && hasOwn(methods, key)) { 24039 warn( 24040 ("Method \"" + key + "\" has already been defined as a data property."), 24041 vm 24042 ); 24043 } 24044 } 24045 if (props && hasOwn(props, key)) { 24046 "development" !== 'production' && warn( 24047 "The data property \"" + key + "\" is already declared as a prop. " + 24048 "Use prop default value instead.", 24049 vm 24050 ); 24051 } else if (!isReserved(key)) { 24052 proxy(vm, "_data", key); 24053 } 24054 } 24055 // observe data 24056 observe(data, true /* asRootData */); 24057} 24058 24059function getData (data, vm) { 24060 try { 24061 return data.call(vm, vm) 24062 } catch (e) { 24063 handleError(e, vm, "data()"); 24064 return {} 24065 } 24066} 24067 24068var computedWatcherOptions = { lazy: true }; 24069 24070function initComputed (vm, computed) { 24071 var watchers = vm._computedWatchers = Object.create(null); 24072 // computed properties are just getters during SSR 24073 var isSSR = isServerRendering(); 24074 24075 for (var key in computed) { 24076 var userDef = computed[key]; 24077 var getter = typeof userDef === 'function' ? userDef : userDef.get; 24078 if ("development" !== 'production' && getter == null) { 24079 warn( 24080 ("Getter is missing for computed property \"" + key + "\"."), 24081 vm 24082 ); 24083 } 24084 24085 if (!isSSR) { 24086 // create internal watcher for the computed property. 24087 watchers[key] = new Watcher( 24088 vm, 24089 getter || noop, 24090 noop, 24091 computedWatcherOptions 24092 ); 24093 } 24094 24095 // component-defined computed properties are already defined on the 24096 // component prototype. We only need to define computed properties defined 24097 // at instantiation here. 24098 if (!(key in vm)) { 24099 defineComputed(vm, key, userDef); 24100 } else { 24101 if (key in vm.$data) { 24102 warn(("The computed property \"" + key + "\" is already defined in data."), vm); 24103 } else if (vm.$options.props && key in vm.$options.props) { 24104 warn(("The computed property \"" + key + "\" is already defined as a prop."), vm); 24105 } 24106 } 24107 } 24108} 24109 24110function defineComputed ( 24111 target, 24112 key, 24113 userDef 24114) { 24115 var shouldCache = !isServerRendering(); 24116 if (typeof userDef === 'function') { 24117 sharedPropertyDefinition.get = shouldCache 24118 ? createComputedGetter(key) 24119 : userDef; 24120 sharedPropertyDefinition.set = noop; 24121 } else { 24122 sharedPropertyDefinition.get = userDef.get 24123 ? shouldCache && userDef.cache !== false 24124 ? createComputedGetter(key) 24125 : userDef.get 24126 : noop; 24127 sharedPropertyDefinition.set = userDef.set 24128 ? userDef.set 24129 : noop; 24130 } 24131 if ("development" !== 'production' && 24132 sharedPropertyDefinition.set === noop) { 24133 sharedPropertyDefinition.set = function () { 24134 warn( 24135 ("Computed property \"" + key + "\" was assigned to but it has no setter."), 24136 this 24137 ); 24138 }; 24139 } 24140 Object.defineProperty(target, key, sharedPropertyDefinition); 24141} 24142 24143function createComputedGetter (key) { 24144 return function computedGetter () { 24145 var watcher = this._computedWatchers && this._computedWatchers[key]; 24146 if (watcher) { 24147 if (watcher.dirty) { 24148 watcher.evaluate(); 24149 } 24150 if (Dep.target) {
24151 watcher.depend(); 24152 } 24153 return watcher.value 24154 } 24155 } 24156} 24157 24158function initMethods (vm, methods) { 24159 var props = vm.$options.props; 24160 for (var key in methods) { 24161 { 24162 if (methods[key] == null) { 24163 warn( 24164 "Method \"" + key + "\" has an undefined value in the component definition. " + 24165 "Did you reference the function correctly?", 24166 vm 24167 ); 24168 } 24169 if (props && hasOwn(props, key)) { 24170 warn( 24171 ("Method \"" + key + "\" has already been defined as a prop."), 24172 vm 24173 ); 24174 } 24175 if ((key in vm) && isReserved(key)) { 24176 warn( 24177 "Method \"" + key + "\" conflicts with an existing Vue instance method. " + 24178 "Avoid defining component methods that start with _ or $." 24179 ); 24180 } 24181 } 24182 vm[key] = methods[key] == null ? noop : bind(methods[key], vm); 24183 } 24184} 24185 24186function initWatch (vm, watch) { 24187 for (var key in watch) { 24188 var handler = watch[key]; 24189 if (Array.isArray(handler)) { 24190 for (var i = 0; i < handler.length; i++) { 24191 createWatcher(vm, key, handler[i]); 24192 } 24193 } else { 24194 createWatcher(vm, key, handler); 24195 } 24196 } 24197} 24198 24199function createWatcher ( 24200 vm, 24201 keyOrFn, 24202 handler, 24203 options 24204) { 24205 if (isPlainObject(handler)) { 24206 options = handler; 24207 handler = handler.handler; 24208 } 24209 if (typeof handler === 'string') { 24210 handler = vm[handler]; 24211 } 24212 return vm.$watch(keyOrFn, handler, options) 24213} 24214 24215function stateMixin (Vue) { 24216 // flow somehow has problems with directly declared definition object 24217 // when using Object.defineProperty, so we have to procedurally build up 24218 // the object here. 24219 var dataDef = {}; 24220 dataDef.get = function () { return this._data }; 24221 var propsDef = {}; 24222 propsDef.get = function () { return this._props }; 24223 { 24224 dataDef.set = function (newData) { 24225 warn( 24226 'Avoid replacing instance root $data. ' + 24227 'Use nested data properties instead.', 24228 this 24229 ); 24230 }; 24231 propsDef.set = function () { 24232 warn("$props is readonly.", this); 24233 }; 24234 } 24235 Object.defineProperty(Vue.prototype, '$data', dataDef); 24236 Object.defineProperty(Vue.prototype, '$props', propsDef); 24237 24238 Vue.prototype.$set = set; 24239 Vue.prototype.$delete = del; 24240 24241 Vue.prototype.$watch = function ( 24242 expOrFn, 24243 cb, 24244 options 24245 ) { 24246 var vm = this; 24247 if (isPlainObject(cb)) { 24248 return createWatcher(vm, expOrFn, cb, options) 24249 } 24250 options = options || {}; 24251 options.user = true; 24252 var watcher = new Watcher(vm, expOrFn, cb, options); 24253 if (options.immediate) { 24254 cb.call(vm, watcher.value); 24255 } 24256 return function unwatchFn () { 24257 watcher.teardown(); 24258 } 24259 }; 24260} 24261 24262/* */ 24263 24264function initProvide (vm) { 24265 var provide = vm.$options.provide; 24266 if (provide) { 24267 vm._provided = typeof provide === 'function' 24268 ? provide.call(vm) 24269 : provide; 24270 } 24271} 24272 24273function initInjections (vm) { 24274 var result = resolveInject(vm.$options.inject, vm); 24275 if (result) { 24276 observerState.shouldConvert = false; 24277 Object.keys(result).forEach(function (key) { 24278 /* istanbul ignore else */ 24279 { 24280 defineReactive(vm, key, result[key], function () { 24281 warn( 24282 "Avoid mutating an injected value directly since the changes will be " + 24283 "overwritten whenever the provided component re-renders. " + 24284 "injection being mutated: \"" + key + "\"", 24285 vm 24286 ); 24287 }); 24288 } 24289 }); 24290 observerState.shouldConvert = true; 24291 } 24292} 24293 24294function resolveInject (inject, vm) { 24295 if (inject) { 24296 // inject is :any because flow is not smart enough to figure out cached 24297 var result = Object.create(null); 24298 var keys = hasSymbol 24299 ? Reflect.ownKeys(inject).filter(function (key) { 24300 /* istanbul ignore next */ 24301 return Object.getOwnPropertyDescriptor(inject, key).enumerable 24302 }) 24303 : Object.keys(inject); 24304 24305 for (var i = 0; i < keys.length; i++) { 24306 var key = keys[i]; 24307 var provideKey = inject[key].from; 24308 var source = vm; 24309 while (source) { 24310 if (source._provided && provideKey in source._provided) { 24311 result[key] = source._provided[provideKey]; 24312 break 24313 } 24314 source = source.$parent; 24315 } 24316 if (!source) { 24317 if ('default' in inject[key]) { 24318 var provideDefault = inject[key].default; 24319 result[key] = typeof provideDefault === 'function' 24320 ? provideDefault.call(vm) 24321 : provideDefault; 24322 } else { 24323 warn(("Injection \"" + key + "\" not found"), vm); 24324 } 24325 } 24326 } 24327 return result 24328 } 24329} 24330 24331/* */ 24332 24333/** 24334 * Runtime helper for rendering v-for lists. 24335 */ 24336function renderList ( 24337 val, 24338 render 24339) { 24340 var ret, i, l, keys, key; 24341 if (Array.isArray(val) || typeof val === 'string') { 24342 ret = new Array(val.length); 24343 for (i = 0, l = val.length; i < l; i++) { 24344 ret[i] = render(val[i], i); 24345 } 24346 } else if (typeof val === 'number') { 24347 ret = new Array(val); 24348 for (i = 0; i < val; i++) { 24349 ret[i] = render(i + 1, i); 24350 } 24351 } else if (isObject(val)) { 24352 keys = Object.keys(val); 24353 ret = new Array(keys.length);
24354 for (i = 0, l = keys.length; i < l; i++) { 24355 key = keys[i]; 24356 ret[i] = render(val[key], key, i); 24357 } 24358 } 24359 if (isDef(ret)) { 24360 (ret)._isVList = true; 24361 } 24362 return ret 24363} 24364 24365/* */ 24366 24367/** 24368 * Runtime helper for rendering <slot> 24369 */ 24370function renderSlot ( 24371 name, 24372 fallback, 24373 props, 24374 bindObject 24375) { 24376 var scopedSlotFn = this.$scopedSlots[name]; 24377 var nodes; 24378 if (scopedSlotFn) { // scoped slot 24379 props = props || {}; 24380 if (bindObject) { 24381 if ("development" !== 'production' && !isObject(bindObject)) { 24382 warn( 24383 'slot v-bind without argument expects an Object', 24384 this 24385 ); 24386 } 24387 props = extend(extend({}, bindObject), props); 24388 } 24389 nodes = scopedSlotFn(props) || fallback; 24390 } else { 24391 var slotNodes = this.$slots[name]; 24392 // warn duplicate slot usage 24393 if (slotNodes) { 24394 if ("development" !== 'production' && slotNodes._rendered) { 24395 warn( 24396 "Duplicate presence of slot \"" + name + "\" found in the same render tree " + 24397 "- this will likely cause render errors.", 24398 this 24399 ); 24400 } 24401 slotNodes._rendered = true; 24402 } 24403 nodes = slotNodes || fallback; 24404 } 24405 24406 var target = props && props.slot; 24407 if (target) { 24408 return this.$createElement('template', { slot: target }, nodes) 24409 } else { 24410 return nodes 24411 } 24412} 24413 24414/* */ 24415 24416/** 24417 * Runtime helper for resolving filters 24418 */ 24419function resolveFilter (id) { 24420 return resolveAsset(this.$options, 'filters', id, true) || identity 24421} 24422 24423/* */ 24424 24425/** 24426 * Runtime helper for checking keyCodes from config. 24427 * exposed as Vue.prototype._k 24428 * passing in eventKeyName as last argument separately for backwards compat 24429 */ 24430function checkKeyCodes ( 24431 eventKeyCode, 24432 key, 24433 builtInAlias, 24434 eventKeyName 24435) { 24436 var keyCodes = config.keyCodes[key] || builtInAlias; 24437 if (keyCodes) { 24438 if (Array.isArray(keyCodes)) { 24439 return keyCodes.indexOf(eventKeyCode) === -1 24440 } else { 24441 return keyCodes !== eventKeyCode 24442 } 24443 } else if (eventKeyName) { 24444 return hyphenate(eventKeyName) !== key 24445 } 24446} 24447 24448/* */ 24449 24450/** 24451 * Runtime helper for merging v-bind="object" into a VNode's data. 24452 */ 24453function bindObjectProps ( 24454 data, 24455 tag, 24456 value, 24457 asProp, 24458 isSync 24459) { 24460 if (value) { 24461 if (!isObject(value)) { 24462 "development" !== 'production' && warn( 24463 'v-bind without argument expects an Object or Array value', 24464 this 24465 ); 24466 } else { 24467 if (Array.isArray(value)) { 24468 value = toObject(value); 24469 } 24470 var hash; 24471 var loop = function ( key ) { 24472 if ( 24473 key === 'class' || 24474 key === 'style' || 24475 isReservedAttribute(key) 24476 ) { 24477 hash = data; 24478 } else { 24479 var type = data.attrs && data.attrs.type; 24480 hash = asProp || config.mustUseProp(tag, type, key) 24481 ? data.domProps || (data.domProps = {}) 24482 : data.attrs || (data.attrs = {}); 24483 } 24484 if (!(key in hash)) { 24485 hash[key] = value[key]; 24486 24487 if (isSync) { 24488 var on = data.on || (data.on = {}); 24489 on[("update:" + key)] = function ($event) { 24490 value[key] = $event; 24491 }; 24492 } 24493 } 24494 }; 24495 24496 for (var key in value) loop( key ); 24497 } 24498 } 24499 return data 24500} 24501 24502/* */ 24503 24504/** 24505 * Runtime helper for rendering static trees. 24506 */
24507function renderStatic ( 24508 index, 24509 isInFor, 24510 isOnce 24511) { 24512 // render fns generated by compiler < 2.5.4 does not provide v-once 24513 // information to runtime so be conservative 24514 var isOldVersion = arguments.length < 3; 24515 // if a static tree is generated by v-once, it is cached on the instance; 24516 // otherwise it is purely static and can be cached on the shared options 24517 // across all instances. 24518 var renderFns = this.$options.staticRenderFns; 24519 var cached = isOldVersion || isOnce 24520 ? (this._staticTrees || (this._staticTrees = [])) 24521 : (renderFns.cached || (renderFns.cached = [])); 24522 var tree = cached[index]; 24523 // if has already-rendered static tree and not inside v-for, 24524 // we can reuse the same tree by doing a shallow clone. 24525 if (tree && !isInFor) { 24526 return Array.isArray(tree) 24527 ? cloneVNodes(tree) 24528 : cloneVNode(tree) 24529 } 24530 // otherwise, render a fresh tree. 24531 tree = cached[index] = renderFns[index].call(this._renderProxy, null, this); 24532 markStatic(tree, ("__static__" + index), false); 24533 return tree 24534} 24535 24536/** 24537 * Runtime helper for v-once. 24538 * Effectively it means marking the node as static with a unique key. 24539 */ 24540function markOnce ( 24541 tree, 24542 index, 24543 key 24544) { 24545 markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true); 24546 return tree 24547} 24548 24549function markStatic ( 24550 tree, 24551 key, 24552 isOnce 24553) { 24554 if (Array.isArray(tree)) { 24555 for (var i = 0; i < tree.length; i++) { 24556 if (tree[i] && typeof tree[i] !== 'string') { 24557 markStaticNode(tree[i], (key + "_" + i), isOnce); 24558 } 24559 } 24560 } else { 24561 markStaticNode(tree, key, isOnce); 24562 } 24563} 24564 24565function markStaticNode (node, key, isOnce) { 24566 node.isStatic = true; 24567 node.key = key; 24568 node.isOnce = isOnce; 24569} 24570 24571/* */ 24572 24573function bindObjectListeners (data, value) { 24574 if (value) { 24575 if (!isPlainObject(value)) { 24576 "development" !== 'production' && warn( 24577 'v-on without argument expects an Object value', 24578 this 24579 ); 24580 } else { 24581 var on = data.on = data.on ? extend({}, data.on) : {}; 24582 for (var key in value) { 24583 var existing = on[key]; 24584 var ours = value[key]; 24585 on[key] = existing ? [].concat(existing, ours) : ours; 24586 } 24587 } 24588 } 24589 return data 24590} 24591 24592/* */ 24593 24594function installRenderHelpers (target) { 24595 target._o = markOnce; 24596 target._n = toNumber; 24597 target._s = toString; 24598 target._l = renderList; 24599 target._t = renderSlot; 24600 target._q = looseEqual; 24601 target._i = looseIndexOf; 24602 target._m = renderStatic; 24603 target._f = resolveFilter; 24604 target._k = checkKeyCodes; 24605 target._b = bindObjectProps; 24606 target._v = createTextVNode; 24607 target._e = createEmptyVNode; 24608 target._u = resolveScopedSlots; 24609 target._g = bindObjectListeners; 24610} 24611 24612/* */ 24613 24614function FunctionalRenderContext ( 24615 data, 24616 props, 24617 children, 24618 parent, 24619 Ctor 24620) { 24621 var options = Ctor.options; 24622 this.data = data; 24623 this.props = props; 24624 this.children = children; 24625 this.parent = parent; 24626 this.listeners = data.on || emptyObject; 24627 this.injections = resolveInject(options.inject, parent); 24628 this.slots = function () { return resolveSlots(children, parent); }; 24629 24630 // ensure the createElement function in functional components 24631 // gets a unique context - this is necessary for correct named slot check 24632 var contextVm = Object.create(parent); 24633 var isCompiled = isTrue(options._compiled); 24634 var needNormalization = !isCompiled; 24635 24636 // support for compiled functional template 24637 if (isCompiled) { 24638 // exposing $options for renderStatic() 24639 this.$options = options; 24640 // pre-resolve slots for renderSlot() 24641 this.$slots = this.slots(); 24642 this.$scopedSlots = data.scopedSlots || emptyObject; 24643 } 24644 24645 if (options._scopeId) { 24646 this._c = function (a, b, c, d) { 24647 var vnode = createElement(contextVm, a, b, c, d, needNormalization); 24648 if (vnode) { 24649 vnode.functionalScopeId = options._scopeId; 24650 vnode.functionalContext = parent; 24651 } 24652 return vnode 24653 }; 24654 } else { 24655 this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); }; 24656 } 24657} 24658 24659installRenderHelpers(FunctionalRenderContext.prototype); 24660 24661function createFunctionalComponent ( 24662 Ctor, 24663 propsData, 24664 data, 24665 contextVm, 24666 children 24667) { 24668 var options = Ctor.options; 24669 var props = {}; 24670 var propOptions = options.props; 24671 if (isDef(propOptions)) { 24672 for (var key in propOptions) { 24673 props[key] = validateProp(key, propOptions, propsData || emptyObject); 24674 } 24675 } else { 24676 if (isDef(data.attrs)) { mergeProps(props, data.attrs); } 24677 if (isDef(data.props)) { mergeProps(props, data.props); } 24678 } 24679 24680 var renderContext = new FunctionalRenderContext( 24681 data, 24682 props, 24683 children, 24684 contextVm, 24685 Ctor 24686 ); 24687 24688 var vnode = options.render.call(null, renderContext._c, renderContext); 24689 24690 if (vnode instanceof VNode) { 24691 vnode.functionalContext = contextVm; 24692 vnode.functionalOptions = options; 24693 if (data.slot) { 24694 (vnode.data || (vnode.data = {})).slot = data.slot; 24695 } 24696 } 24697 24698 return vnode 24699} 24700 24701function mergeProps (to, from) { 24702 for (var key in from) { 24703 to[camelize(key)] = from[key]; 24704 } 24705} 24706 24707/* */ 24708 24709// hooks to be invoked on component VNodes during patch
vendor: 8,664 bytes, lines 24710-25015
24710var componentVNodeHooks = { 24711 init: function init ( 24712 vnode, 24713 hydrating, 24714 parentElm, 24715 refElm 24716 ) { 24717 if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) { 24718 var child = vnode.componentInstance = createComponentInstanceForVnode( 24719 vnode, 24720 activeInstance, 24721 parentElm, 24722 refElm 24723 ); 24724 child.$mount(hydrating ? vnode.elm : undefined, hydrating); 24725 } else if (vnode.data.keepAlive) { 24726 // kept-alive components, treat as a patch 24727 var mountedNode = vnode; // work around flow 24728 componentVNodeHooks.prepatch(mountedNode, mountedNode); 24729 } 24730 }, 24731 24732 prepatch: function prepatch (oldVnode, vnode) { 24733 var options = vnode.componentOptions; 24734 var child = vnode.componentInstance = oldVnode.componentInstance; 24735 updateChildComponent( 24736 child, 24737 options.propsData, // updated props 24738 options.listeners, // updated listeners 24739 vnode, // new parent vnode 24740 options.children // new children 24741 ); 24742 }, 24743 24744 insert: function insert (vnode) { 24745 var context = vnode.context; 24746 var componentInstance = vnode.componentInstance; 24747 if (!componentInstance._isMounted) { 24748 componentInstance._isMounted = true; 24749 callHook(componentInstance, 'mounted'); 24750 } 24751 if (vnode.data.keepAlive) { 24752 if (context._isMounted) { 24753 // vue-router#1212 24754 // During updates, a kept-alive component's child components may 24755 // change, so directly walking the tree here may call activated hooks 24756 // on incorrect children. Instead we push them into a queue which will 24757 // be processed after the whole patch process ended. 24758 queueActivatedComponent(componentInstance); 24759 } else { 24760 activateChildComponent(componentInstance, true /* direct */); 24761 } 24762 } 24763 }, 24764 24765 destroy: function destroy (vnode) { 24766 var componentInstance = vnode.componentInstance; 24767 if (!componentInstance._isDestroyed) { 24768 if (!vnode.data.keepAlive) { 24769 componentInstance.$destroy(); 24770 } else { 24771 deactivateChildComponent(componentInstance, true /* direct */); 24772 } 24773 } 24774 } 24775}; 24776 24777var hooksToMerge = Object.keys(componentVNodeHooks); 24778 24779function createComponent ( 24780 Ctor, 24781 data, 24782 context, 24783 children, 24784 tag 24785) { 24786 if (isUndef(Ctor)) { 24787 return 24788 } 24789 24790 var baseCtor = context.$options._base; 24791 24792 // plain options object: turn it into a constructor 24793 if (isObject(Ctor)) { 24794 Ctor = baseCtor.extend(Ctor); 24795 } 24796 24797 // if at this stage it's not a constructor or an async component factory, 24798 // reject. 24799 if (typeof Ctor !== 'function') { 24800 { 24801 warn(("Invalid Component definition: " + (String(Ctor))), context); 24802 } 24803 return 24804 } 24805 24806 // async component 24807 var asyncFactory; 24808 if (isUndef(Ctor.cid)) { 24809 asyncFactory = Ctor; 24810 Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context); 24811 if (Ctor === undefined) { 24812 // return a placeholder node for async component, which is rendered 24813 // as a comment node but preserves all the raw information for the node. 24814 // the information will be used for async server-rendering and hydration. 24815 return createAsyncPlaceholder( 24816 asyncFactory, 24817 data, 24818 context, 24819 children, 24820 tag 24821 ) 24822 } 24823 } 24824 24825 data = data || {}; 24826 24827 // resolve constructor options in case global mixins are applied after 24828 // component constructor creation 24829 resolveConstructorOptions(Ctor); 24830 24831 // transform component v-model data into props & events 24832 if (isDef(data.model)) { 24833 transformModel(Ctor.options, data); 24834 } 24835 24836 // extract props 24837 var propsData = extractPropsFromVNodeData(data, Ctor, tag); 24838 24839 // functional component 24840 if (isTrue(Ctor.options.functional)) { 24841 return createFunctionalComponent(Ctor, propsData, data, context, children) 24842 } 24843 24844 // extract listeners, since these needs to be treated as 24845 // child component listeners instead of DOM listeners 24846 var listeners = data.on; 24847 // replace with listeners with .native modifier 24848 // so it gets processed during parent component patch. 24849 data.on = data.nativeOn; 24850 24851 if (isTrue(Ctor.options.abstract)) { 24852 // abstract components do not keep anything 24853 // other than props & listeners & slot 24854 24855 // work around flow 24856 var slot = data.slot; 24857 data = {}; 24858 if (slot) { 24859 data.slot = slot; 24860 } 24861 } 24862 24863 // merge component management hooks onto the placeholder node 24864 mergeHooks(data); 24865 24866 // return a placeholder vnode 24867 var name = Ctor.options.name || tag; 24868 var vnode = new VNode( 24869 ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), 24870 data, undefined, undefined, undefined, context, 24871 { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, 24872 asyncFactory 24873 ); 24874 return vnode 24875} 24876 24877function createComponentInstanceForVnode ( 24878 vnode, // we know it's MountedComponentVNode but flow doesn't 24879 parent, // activeInstance in lifecycle state 24880 parentElm, 24881 refElm 24882) { 24883 var vnodeComponentOptions = vnode.componentOptions; 24884 var options = { 24885 _isComponent: true, 24886 parent: parent, 24887 propsData: vnodeComponentOptions.propsData, 24888 _componentTag: vnodeComponentOptions.tag, 24889 _parentVnode: vnode, 24890 _parentListeners: vnodeComponentOptions.listeners, 24891 _renderChildren: vnodeComponentOptions.children, 24892 _parentElm: parentElm || null, 24893 _refElm: refElm || null 24894 }; 24895 // check inline-template render functions 24896 var inlineTemplate = vnode.data.inlineTemplate; 24897 if (isDef(inlineTemplate)) { 24898 options.render = inlineTemplate.render; 24899 options.staticRenderFns = inlineTemplate.staticRenderFns; 24900 } 24901 return new vnodeComponentOptions.Ctor(options) 24902} 24903 24904function mergeHooks (data) { 24905 if (!data.hook) { 24906 data.hook = {}; 24907 } 24908 for (var i = 0; i < hooksToMerge.length; i++) { 24909 var key = hooksToMerge[i]; 24910 var fromParent = data.hook[key]; 24911 var ours = componentVNodeHooks[key]; 24912 data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours; 24913 } 24914} 24915 24916function mergeHook$1 (one, two) { 24917 return function (a, b, c, d) { 24918 one(a, b, c, d); 24919 two(a, b, c, d); 24920 } 24921} 24922 24923// transform component v-model info (value and callback) into 24924// prop and event handler respectively. 24925function transformModel (options, data) { 24926 var prop = (options.model && options.model.prop) || 'value'; 24927 var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value; 24928 var on = data.on || (data.on = {}); 24929 if (isDef(on[event])) { 24930 on[event] = [data.model.callback].concat(on[event]); 24931 } else { 24932 on[event] = data.model.callback; 24933 } 24934} 24935 24936/* */ 24937 24938var SIMPLE_NORMALIZE = 1; 24939var ALWAYS_NORMALIZE = 2; 24940 24941// wrapper function for providing a more flexible interface 24942// without getting yelled at by flow 24943function createElement ( 24944 context, 24945 tag, 24946 data, 24947 children, 24948 normalizationType, 24949 alwaysNormalize 24950) { 24951 if (Array.isArray(data) || isPrimitive(data)) { 24952 normalizationType = children; 24953 children = data; 24954 data = undefined; 24955 } 24956 if (isTrue(alwaysNormalize)) { 24957 normalizationType = ALWAYS_NORMALIZE; 24958 } 24959 return _createElement(context, tag, data, children, normalizationType) 24960} 24961 24962function _createElement ( 24963 context, 24964 tag, 24965 data, 24966 children, 24967 normalizationType 24968) { 24969 if (isDef(data) && isDef((data).__ob__)) { 24970 "development" !== 'production' && warn( 24971 "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 24972 'Always create fresh vnode data objects in each render!', 24973 context 24974 ); 24975 return createEmptyVNode() 24976 } 24977 // object syntax in v-bind 24978 if (isDef(data) && isDef(data.is)) { 24979 tag = data.is; 24980 } 24981 if (!tag) { 24982 // in case of component :is set to falsy value 24983 return createEmptyVNode() 24984 } 24985 // warn against non-primitive key 24986 if ("development" !== 'production' && 24987 isDef(data) && isDef(data.key) && !isPrimitive(data.key) 24988 ) { 24989 warn( 24990 'Avoid using non-primitive value as key, ' + 24991 'use string/number value instead.', 24992 context 24993 ); 24994 } 24995 // support single function children as default scoped slot 24996 if (Array.isArray(children) && 24997 typeof children[0] === 'function' 24998 ) { 24999 data = data || {}; 25000 data.scopedSlots = { default: children[0] }; 25001 children.length = 0; 25002 } 25003 if (normalizationType === ALWAYS_NORMALIZE) { 25004 children = normalizeChildren(children); 25005 } else if (normalizationType === SIMPLE_NORMALIZE) { 25006 children = simpleNormalizeChildren(children); 25007 } 25008 var vnode, ns; 25009 if (typeof tag === 'string') { 25010 var Ctor; 25011 ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag); 25012 if (config.isReservedTag(tag)) { 25013 // platform built-in elements 25014 vnode = new VNode( 25015 config.parsePlatformTagName(tag), data, children,
25016 undefined, undefined, context 25017 ); 25018 } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) { 25019 // component 25020 vnode = createComponent(Ctor, data, context, children, tag); 25021 } else { 25022 // unknown or unlisted namespaced elements 25023 // check at runtime because it may get assigned a namespace when its 25024 // parent normalizes children 25025 vnode = new VNode( 25026 tag, data, children, 25027 undefined, undefined, context 25028 ); 25029 } 25030 } else { 25031 // direct component options / constructor 25032 vnode = createComponent(tag, data, context, children); 25033 } 25034 if (isDef(vnode)) { 25035 if (ns) { applyNS(vnode, ns); } 25036 return vnode 25037 } else { 25038 return createEmptyVNode() 25039 } 25040} 25041 25042function applyNS (vnode, ns, force) { 25043 vnode.ns = ns; 25044 if (vnode.tag === 'foreignObject') { 25045 // use default namespace inside foreignObject 25046 ns = undefined; 25047 force = true; 25048 } 25049 if (isDef(vnode.children)) { 25050 for (var i = 0, l = vnode.children.length; i < l; i++) { 25051 var child = vnode.children[i]; 25052 if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) { 25053 applyNS(child, ns, force); 25054 } 25055 } 25056 } 25057} 25058 25059/* */ 25060 25061function initRender (vm) { 25062 vm._vnode = null; // the root of the child tree 25063 vm._staticTrees = null; // v-once cached trees 25064 var options = vm.$options; 25065 var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree 25066 var renderContext = parentVnode && parentVnode.context; 25067 vm.$slots = resolveSlots(options._renderChildren, renderContext); 25068 vm.$scopedSlots = emptyObject; 25069 // bind the createElement fn to this instance 25070 // so that we get proper render context inside it. 25071 // args order: tag, data, children, normalizationType, alwaysNormalize 25072 // internal version is used by render functions compiled from templates 25073 vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); }; 25074 // normalization is always applied for the public version, used in 25075 // user-written render functions. 25076 vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); }; 25077 25078 // $attrs & $listeners are exposed for easier HOC creation. 25079 // they need to be reactive so that HOCs using them are always updated 25080 var parentData = parentVnode && parentVnode.data; 25081 25082 /* istanbul ignore else */ 25083 { 25084 defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () { 25085 !isUpdatingChildComponent && warn("$attrs is readonly.", vm); 25086 }, true); 25087 defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () { 25088 !isUpdatingChildComponent && warn("$listeners is readonly.", vm); 25089 }, true); 25090 } 25091} 25092 25093function renderMixin (Vue) { 25094 // install runtime convenience helpers 25095 installRenderHelpers(Vue.prototype); 25096 25097 Vue.prototype.$nextTick = function (fn) { 25098 return nextTick(fn, this) 25099 }; 25100 25101 Vue.prototype._render = function () { 25102 var vm = this; 25103 var ref = vm.$options; 25104 var render = ref.render; 25105 var _parentVnode = ref._parentVnode; 25106 25107 if (vm._isMounted) { 25108 // if the parent didn't update, the slot nodes will be the ones from 25109 // last render. They need to be cloned to ensure "freshness" for this render. 25110 for (var key in vm.$slots) { 25111 var slot = vm.$slots[key]; 25112 // _rendered is a flag added by renderSlot, but may not be present 25113 // if the slot is passed from manually written render functions 25114 if (slot._rendered || (slot[0] && slot[0].elm)) { 25115 vm.$slots[key] = cloneVNodes(slot, true /* deep */); 25116 } 25117 } 25118 } 25119 25120 vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject; 25121 25122 // set parent vnode. this allows render functions to have access 25123 // to the data on the placeholder node. 25124 vm.$vnode = _parentVnode; 25125 // render self 25126 var vnode; 25127 try { 25128 vnode = render.call(vm._renderProxy, vm.$createElement); 25129 } catch (e) { 25130 handleError(e, vm, "render"); 25131 // return error render result, 25132 // or previous vnode to prevent render error causing blank component 25133 /* istanbul ignore else */ 25134 { 25135 if (vm.$options.renderError) { 25136 try { 25137 vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e); 25138 } catch (e) { 25139 handleError(e, vm, "renderError"); 25140 vnode = vm._vnode; 25141 } 25142 } else { 25143 vnode = vm._vnode; 25144 } 25145 } 25146 } 25147 // return empty vnode in case the render function errored out 25148 if (!(vnode instanceof VNode)) { 25149 if ("development" !== 'production' && Array.isArray(vnode)) { 25150 warn( 25151 'Multiple root nodes returned from render function. Render function ' + 25152 'should return a single root node.', 25153 vm 25154 ); 25155 } 25156 vnode = createEmptyVNode(); 25157 } 25158 // set parent 25159 vnode.parent = _parentVnode; 25160 return vnode 25161 }; 25162} 25163 25164/* */ 25165 25166var uid$1 = 0; 25167 25168function initMixin (Vue) { 25169 Vue.prototype._init = function (options) { 25170 var vm = this; 25171 // a uid 25172 vm._uid = uid$1++; 25173 25174 var startTag, endTag; 25175 /* istanbul ignore if */ 25176 if ("development" !== 'production' && config.performance && mark) { 25177 startTag = "vue-perf-start:" + (vm._uid); 25178 endTag = "vue-perf-end:" + (vm._uid); 25179 mark(startTag); 25180 } 25181 25182 // a flag to avoid this being observed 25183 vm._isVue = true; 25184 // merge options 25185 if (options && options._isComponent) {
vendor: 6,718 bytes, lines 25186-25422
25186 // optimize internal component instantiation 25187 // since dynamic options merging is pretty slow, and none of the 25188 // internal component options needs special treatment. 25189 initInternalComponent(vm, options); 25190 } else { 25191 vm.$options = mergeOptions( 25192 resolveConstructorOptions(vm.constructor), 25193 options || {}, 25194 vm 25195 ); 25196 } 25197 /* istanbul ignore else */ 25198 { 25199 initProxy(vm); 25200 } 25201 // expose real self 25202 vm._self = vm; 25203 initLifecycle(vm); 25204 initEvents(vm); 25205 initRender(vm); 25206 callHook(vm, 'beforeCreate'); 25207 initInjections(vm); // resolve injections before data/props 25208 initState(vm); 25209 initProvide(vm); // resolve provide after data/props 25210 callHook(vm, 'created'); 25211 25212 /* istanbul ignore if */ 25213 if ("development" !== 'production' && config.performance && mark) { 25214 vm._name = formatComponentName(vm, false); 25215 mark(endTag); 25216 measure(("vue " + (vm._name) + " init"), startTag, endTag); 25217 } 25218 25219 if (vm.$options.el) { 25220 vm.$mount(vm.$options.el); 25221 } 25222 }; 25223} 25224 25225function initInternalComponent (vm, options) { 25226 var opts = vm.$options = Object.create(vm.constructor.options); 25227 // doing this because it's faster than dynamic enumeration. 25228 opts.parent = options.parent; 25229 opts.propsData = options.propsData; 25230 opts._parentVnode = options._parentVnode; 25231 opts._parentListeners = options._parentListeners; 25232 opts._renderChildren = options._renderChildren; 25233 opts._componentTag = options._componentTag; 25234 opts._parentElm = options._parentElm; 25235 opts._refElm = options._refElm; 25236 if (options.render) { 25237 opts.render = options.render; 25238 opts.staticRenderFns = options.staticRenderFns; 25239 } 25240} 25241 25242function resolveConstructorOptions (Ctor) { 25243 var options = Ctor.options; 25244 if (Ctor.super) { 25245 var superOptions = resolveConstructorOptions(Ctor.super); 25246 var cachedSuperOptions = Ctor.superOptions; 25247 if (superOptions !== cachedSuperOptions) { 25248 // super option changed, 25249 // need to resolve new options. 25250 Ctor.superOptions = superOptions; 25251 // check if there are any late-modified/attached options (#4976) 25252 var modifiedOptions = resolveModifiedOptions(Ctor); 25253 // update base extend options 25254 if (modifiedOptions) { 25255 extend(Ctor.extendOptions, modifiedOptions); 25256 } 25257 options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); 25258 if (options.name) { 25259 options.components[options.name] = Ctor; 25260 } 25261 } 25262 } 25263 return options 25264} 25265 25266function resolveModifiedOptions (Ctor) { 25267 var modified; 25268 var latest = Ctor.options; 25269 var extended = Ctor.extendOptions; 25270 var sealed = Ctor.sealedOptions; 25271 for (var key in latest) { 25272 if (latest[key] !== sealed[key]) { 25273 if (!modified) { modified = {}; } 25274 modified[key] = dedupe(latest[key], extended[key], sealed[key]); 25275 } 25276 } 25277 return modified 25278} 25279 25280function dedupe (latest, extended, sealed) { 25281 // compare latest and sealed to ensure lifecycle hooks won't be duplicated 25282 // between merges 25283 if (Array.isArray(latest)) { 25284 var res = []; 25285 sealed = Array.isArray(sealed) ? sealed : [sealed]; 25286 extended = Array.isArray(extended) ? extended : [extended]; 25287 for (var i = 0; i < latest.length; i++) { 25288 // push original options and not sealed options to exclude duplicated options 25289 if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) { 25290 res.push(latest[i]); 25291 } 25292 } 25293 return res 25294 } else { 25295 return latest 25296 } 25297} 25298 25299function Vue$3 (options) { 25300 if ("development" !== 'production' && 25301 !(this instanceof Vue$3) 25302 ) { 25303 warn('Vue is a constructor and should be called with the `new` keyword'); 25304 } 25305 this._init(options); 25306} 25307 25308initMixin(Vue$3); 25309stateMixin(Vue$3); 25310eventsMixin(Vue$3); 25311lifecycleMixin(Vue$3); 25312renderMixin(Vue$3); 25313 25314/* */ 25315 25316function initUse (Vue) { 25317 Vue.use = function (plugin) { 25318 var installedPlugins = (this._installedPlugins || (this._installedPlugins = [])); 25319 if (installedPlugins.indexOf(plugin) > -1) { 25320 return this 25321 } 25322 25323 // additional parameters 25324 var args = toArray(arguments, 1); 25325 args.unshift(this); 25326 if (typeof plugin.install === 'function') { 25327 plugin.install.apply(plugin, args); 25328 } else if (typeof plugin === 'function') { 25329 plugin.apply(null, args); 25330 } 25331 installedPlugins.push(plugin); 25332 return this 25333 }; 25334} 25335 25336/* */ 25337 25338function initMixin$1 (Vue) { 25339 Vue.mixin = function (mixin) { 25340 this.options = mergeOptions(this.options, mixin); 25341 return this 25342 }; 25343} 25344 25345/* */ 25346 25347function initExtend (Vue) { 25348 /** 25349 * Each instance constructor, including Vue, has a unique 25350 * cid. This enables us to create wrapped "child 25351 * constructors" for prototypal inheritance and cache them. 25352 */ 25353 Vue.cid = 0; 25354 var cid = 1; 25355 25356 /** 25357 * Class inheritance 25358 */ 25359 Vue.extend = function (extendOptions) { 25360 extendOptions = extendOptions || {}; 25361 var Super = this; 25362 var SuperId = Super.cid; 25363 var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); 25364 if (cachedCtors[SuperId]) { 25365 return cachedCtors[SuperId] 25366 } 25367 25368 var name = extendOptions.name || Super.options.name; 25369 { 25370 if (!/^[a-zA-Z][\w-]*$/.test(name)) { 25371 warn( 25372 'Invalid component name: "' + name + '". Component names ' + 25373 'can only contain alphanumeric characters and the hyphen, ' + 25374 'and must start with a letter.' 25375 ); 25376 } 25377 } 25378 25379 var Sub = function VueComponent (options) { 25380 this._init(options); 25381 }; 25382 Sub.prototype = Object.create(Super.prototype); 25383 Sub.prototype.constructor = Sub; 25384 Sub.cid = cid++; 25385 Sub.options = mergeOptions( 25386 Super.options, 25387 extendOptions 25388 ); 25389 Sub['super'] = Super; 25390 25391 // For props and computed properties, we define the proxy getters on 25392 // the Vue instances at extension time, on the extended prototype. This 25393 // avoids Object.defineProperty calls for each instance created. 25394 if (Sub.options.props) { 25395 initProps$1(Sub); 25396 } 25397 if (Sub.options.computed) { 25398 initComputed$1(Sub); 25399 } 25400 25401 // allow further extension/mixin/plugin usage 25402 Sub.extend = Super.extend; 25403 Sub.mixin = Super.mixin; 25404 Sub.use = Super.use; 25405 25406 // create asset registers, so extended classes 25407 // can have their private assets too. 25408 ASSET_TYPES.forEach(function (type) { 25409 Sub[type] = Super[type]; 25410 }); 25411 // enable recursive self-lookup 25412 if (name) { 25413 Sub.options.components[name] = Sub; 25414 } 25415 25416 // keep a reference to the super options at extension time. 25417 // later at instantiation we can check if Super's options have 25418 // been updated. 25419 Sub.superOptions = Super.options; 25420 Sub.extendOptions = extendOptions; 25421 Sub.sealedOptions = extend({}, Sub.options); 25422
vendor: 4,107 bytes, lines 25423-25588
25423 // cache constructor 25424 cachedCtors[SuperId] = Sub; 25425 return Sub 25426 }; 25427} 25428 25429function initProps$1 (Comp) { 25430 var props = Comp.options.props; 25431 for (var key in props) { 25432 proxy(Comp.prototype, "_props", key); 25433 } 25434} 25435 25436function initComputed$1 (Comp) { 25437 var computed = Comp.options.computed; 25438 for (var key in computed) { 25439 defineComputed(Comp.prototype, key, computed[key]); 25440 } 25441} 25442 25443/* */ 25444 25445function initAssetRegisters (Vue) { 25446 /** 25447 * Create asset registration methods. 25448 */ 25449 ASSET_TYPES.forEach(function (type) { 25450 Vue[type] = function ( 25451 id, 25452 definition 25453 ) { 25454 if (!definition) { 25455 return this.options[type + 's'][id] 25456 } else { 25457 /* istanbul ignore if */ 25458 { 25459 if (type === 'component' && config.isReservedTag(id)) { 25460 warn( 25461 'Do not use built-in or reserved HTML elements as component ' + 25462 'id: ' + id 25463 ); 25464 } 25465 } 25466 if (type === 'component' && isPlainObject(definition)) { 25467 definition.name = definition.name || id; 25468 definition = this.options._base.extend(definition); 25469 } 25470 if (type === 'directive' && typeof definition === 'function') { 25471 definition = { bind: definition, update: definition }; 25472 } 25473 this.options[type + 's'][id] = definition; 25474 return definition 25475 } 25476 }; 25477 }); 25478} 25479 25480/* */ 25481 25482function getComponentName (opts) { 25483 return opts && (opts.Ctor.options.name || opts.tag) 25484} 25485 25486function matches (pattern, name) { 25487 if (Array.isArray(pattern)) { 25488 return pattern.indexOf(name) > -1 25489 } else if (typeof pattern === 'string') { 25490 return pattern.split(',').indexOf(name) > -1 25491 } else if (isRegExp(pattern)) { 25492 return pattern.test(name) 25493 } 25494 /* istanbul ignore next */ 25495 return false 25496} 25497 25498function pruneCache (keepAliveInstance, filter) { 25499 var cache = keepAliveInstance.cache; 25500 var keys = keepAliveInstance.keys; 25501 var _vnode = keepAliveInstance._vnode; 25502 for (var key in cache) { 25503 var cachedNode = cache[key]; 25504 if (cachedNode) { 25505 var name = getComponentName(cachedNode.componentOptions); 25506 if (name && !filter(name)) { 25507 pruneCacheEntry(cache, key, keys, _vnode); 25508 } 25509 } 25510 } 25511} 25512 25513function pruneCacheEntry ( 25514 cache, 25515 key, 25516 keys, 25517 current 25518) { 25519 var cached$$1 = cache[key]; 25520 if (cached$$1 && cached$$1 !== current) { 25521 cached$$1.componentInstance.$destroy(); 25522 } 25523 cache[key] = null; 25524 remove(keys, key); 25525} 25526 25527var patternTypes = [String, RegExp, Array]; 25528 25529var KeepAlive = { 25530 name: 'keep-alive', 25531 abstract: true, 25532 25533 props: { 25534 include: patternTypes, 25535 exclude: patternTypes, 25536 max: [String, Number] 25537 }, 25538 25539 created: function created () { 25540 this.cache = Object.create(null); 25541 this.keys = []; 25542 }, 25543 25544 destroyed: function destroyed () { 25545 var this$1 = this; 25546 25547 for (var key in this$1.cache) { 25548 pruneCacheEntry(this$1.cache, key, this$1.keys); 25549 } 25550 }, 25551 25552 watch: { 25553 include: function include (val) { 25554 pruneCache(this, function (name) { return matches(val, name); }); 25555 }, 25556 exclude: function exclude (val) { 25557 pruneCache(this, function (name) { return !matches(val, name); }); 25558 } 25559 }, 25560 25561 render: function render () { 25562 var slot = this.$slots.default; 25563 var vnode = getFirstComponentChild(slot); 25564 var componentOptions = vnode && vnode.componentOptions; 25565 if (componentOptions) { 25566 // check pattern 25567 var name = getComponentName(componentOptions); 25568 var ref = this; 25569 var include = ref.include; 25570 var exclude = ref.exclude; 25571 if ( 25572 // not included 25573 (include && (!name || !matches(include, name))) || 25574 // excluded 25575 (exclude && name && matches(exclude, name)) 25576 ) { 25577 return vnode 25578 } 25579 25580 var ref$1 = this; 25581 var cache = ref$1.cache; 25582 var keys = ref$1.keys; 25583 var key = vnode.key == null 25584 // same constructor may get registered as different local components 25585 // so cid alone is not enough (#3269) 25586 ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '') 25587 : vnode.key; 25588 if (cache[key]) {
vendor: 15,067 bytes, lines 25589-26174
25589 vnode.componentInstance = cache[key].componentInstance; 25590 // make current key freshest 25591 remove(keys, key); 25592 keys.push(key); 25593 } else { 25594 cache[key] = vnode; 25595 keys.push(key); 25596 // prune oldest entry 25597 if (this.max && keys.length > parseInt(this.max)) { 25598 pruneCacheEntry(cache, keys[0], keys, this._vnode); 25599 } 25600 } 25601 25602 vnode.data.keepAlive = true; 25603 } 25604 return vnode || (slot && slot[0]) 25605 } 25606}; 25607 25608var builtInComponents = { 25609 KeepAlive: KeepAlive 25610}; 25611 25612/* */ 25613 25614function initGlobalAPI (Vue) { 25615 // config 25616 var configDef = {}; 25617 configDef.get = function () { return config; }; 25618 { 25619 configDef.set = function () { 25620 warn( 25621 'Do not replace the Vue.config object, set individual fields instead.' 25622 ); 25623 }; 25624 } 25625 Object.defineProperty(Vue, 'config', configDef); 25626 25627 // exposed util methods. 25628 // NOTE: these are not considered part of the public API - avoid relying on 25629 // them unless you are aware of the risk. 25630 Vue.util = { 25631 warn: warn, 25632 extend: extend, 25633 mergeOptions: mergeOptions, 25634 defineReactive: defineReactive 25635 }; 25636 25637 Vue.set = set; 25638 Vue.delete = del; 25639 Vue.nextTick = nextTick; 25640 25641 Vue.options = Object.create(null); 25642 ASSET_TYPES.forEach(function (type) { 25643 Vue.options[type + 's'] = Object.create(null); 25644 }); 25645 25646 // this is used to identify the "base" constructor to extend all plain-object 25647 // components with in Weex's multi-instance scenarios. 25648 Vue.options._base = Vue; 25649 25650 extend(Vue.options.components, builtInComponents); 25651 25652 initUse(Vue); 25653 initMixin$1(Vue); 25654 initExtend(Vue); 25655 initAssetRegisters(Vue); 25656} 25657 25658initGlobalAPI(Vue$3); 25659 25660Object.defineProperty(Vue$3.prototype, '$isServer', { 25661 get: isServerRendering 25662}); 25663 25664Object.defineProperty(Vue$3.prototype, '$ssrContext', { 25665 get: function get () { 25666 /* istanbul ignore next */ 25667 return this.$vnode && this.$vnode.ssrContext 25668 } 25669}); 25670 25671Vue$3.version = '2.5.8'; 25672 25673/* */ 25674 25675// these are reserved for web because they are directly compiled away 25676// during template compilation 25677var isReservedAttr = makeMap('style,class'); 25678 25679// attributes that should be using props for binding 25680var acceptValue = makeMap('input,textarea,option,select,progress'); 25681var mustUseProp = function (tag, type, attr) { 25682 return ( 25683 (attr === 'value' && acceptValue(tag)) && type !== 'button' || 25684 (attr === 'selected' && tag === 'option') || 25685 (attr === 'checked' && tag === 'input') || 25686 (attr === 'muted' && tag === 'video') 25687 ) 25688}; 25689 25690var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); 25691 25692var isBooleanAttr = makeMap( 25693 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 25694 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 25695 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 25696 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 25697 'required,reversed,scoped,seamless,selected,sortable,translate,' + 25698 'truespeed,typemustmatch,visible' 25699); 25700 25701var xlinkNS = 'http://www.w3.org/1999/xlink'; 25702 25703var isXlink = function (name) { 25704 return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' 25705}; 25706 25707var getXlinkProp = function (name) { 25708 return isXlink(name) ? name.slice(6, name.length) : '' 25709}; 25710 25711var isFalsyAttrValue = function (val) { 25712 return val == null || val === false 25713}; 25714 25715/* */ 25716 25717function genClassForVnode (vnode) { 25718 var data = vnode.data; 25719 var parentNode = vnode; 25720 var childNode = vnode; 25721 while (isDef(childNode.componentInstance)) { 25722 childNode = childNode.componentInstance._vnode; 25723 if (childNode.data) { 25724 data = mergeClassData(childNode.data, data); 25725 } 25726 } 25727 while (isDef(parentNode = parentNode.parent)) { 25728 if (parentNode.data) { 25729 data = mergeClassData(data, parentNode.data); 25730 } 25731 } 25732 return renderClass(data.staticClass, data.class) 25733} 25734 25735function mergeClassData (child, parent) { 25736 return { 25737 staticClass: concat(child.staticClass, parent.staticClass), 25738 class: isDef(child.class) 25739 ? [child.class, parent.class] 25740 : parent.class 25741 } 25742} 25743 25744function renderClass ( 25745 staticClass, 25746 dynamicClass 25747) { 25748 if (isDef(staticClass) || isDef(dynamicClass)) { 25749 return concat(staticClass, stringifyClass(dynamicClass)) 25750 } 25751 /* istanbul ignore next */ 25752 return '' 25753} 25754 25755function concat (a, b) { 25756 return a ? b ? (a + ' ' + b) : a : (b || '') 25757} 25758 25759function stringifyClass (value) { 25760 if (Array.isArray(value)) { 25761 return stringifyArray(value) 25762 } 25763 if (isObject(value)) { 25764 return stringifyObject(value) 25765 } 25766 if (typeof value === 'string') { 25767 return value 25768 } 25769 /* istanbul ignore next */ 25770 return '' 25771} 25772 25773function stringifyArray (value) { 25774 var res = ''; 25775 var stringified; 25776 for (var i = 0, l = value.length; i < l; i++) { 25777 if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') { 25778 if (res) { res += ' '; } 25779 res += stringified; 25780 } 25781 } 25782 return res 25783} 25784 25785function stringifyObject (value) { 25786 var res = ''; 25787 for (var key in value) { 25788 if (value[key]) { 25789 if (res) { res += ' '; } 25790 res += key; 25791 } 25792 } 25793 return res 25794} 25795 25796/* */ 25797 25798var namespaceMap = { 25799 svg: 'http://www.w3.org/2000/svg', 25800 math: 'http://www.w3.org/1998/Math/MathML' 25801}; 25802 25803var isHTMLTag = makeMap( 25804 'html,body,base,head,link,meta,style,title,' + 25805 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 25806 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 25807 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 25808 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 25809 'embed,object,param,source,canvas,script,noscript,del,ins,' + 25810 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 25811 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 25812 'output,progress,select,textarea,' + 25813 'details,dialog,menu,menuitem,summary,' + 25814 'content,element,shadow,template,blockquote,iframe,tfoot' 25815); 25816 25817// this map is intentionally selective, only covering SVG elements that may 25818// contain child elements. 25819var isSVG = makeMap( 25820 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 25821 'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 25822 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', 25823 true 25824); 25825 25826var isPreTag = function (tag) { return tag === 'pre'; }; 25827 25828var isReservedTag = function (tag) { 25829 return isHTMLTag(tag) || isSVG(tag) 25830}; 25831 25832function getTagNamespace (tag) { 25833 if (isSVG(tag)) { 25834 return 'svg' 25835 } 25836 // basic support for MathML 25837 // note it doesn't support other MathML elements being component roots 25838 if (tag === 'math') { 25839 return 'math' 25840 } 25841} 25842 25843var unknownElementCache = Object.create(null); 25844function isUnknownElement (tag) { 25845 /* istanbul ignore if */ 25846 if (!inBrowser) { 25847 return true 25848 } 25849 if (isReservedTag(tag)) { 25850 return false 25851 } 25852 tag = tag.toLowerCase(); 25853 /* istanbul ignore if */ 25854 if (unknownElementCache[tag] != null) { 25855 return unknownElementCache[tag] 25856 } 25857 var el = document.createElement(tag); 25858 if (tag.indexOf('-') > -1) { 25859 // http://stackoverflow.com/a/28210364/1070244 25860 return (unknownElementCache[tag] = ( 25861 el.constructor === window.HTMLUnknownElement || 25862 el.constructor === window.HTMLElement 25863 )) 25864 } else { 25865 return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) 25866 } 25867} 25868 25869var isTextInputType = makeMap('text,number,password,search,email,tel,url'); 25870 25871/* */ 25872 25873/** 25874 * Query an element selector if it's not an element already. 25875 */ 25876function query (el) { 25877 if (typeof el === 'string') { 25878 var selected = document.querySelector(el); 25879 if (!selected) { 25880 "development" !== 'production' && warn( 25881 'Cannot find element: ' + el 25882 ); 25883 return document.createElement('div') 25884 } 25885 return selected 25886 } else { 25887 return el 25888 } 25889} 25890 25891/* */ 25892 25893function createElement$1 (tagName, vnode) { 25894 var elm = document.createElement(tagName); 25895 if (tagName !== 'select') { 25896 return elm 25897 } 25898 // false or null will remove the attribute but undefined will not 25899 if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) { 25900 elm.setAttribute('multiple', 'multiple'); 25901 } 25902 return elm 25903} 25904 25905function createElementNS (namespace, tagName) { 25906 return document.createElementNS(namespaceMap[namespace], tagName) 25907} 25908 25909function createTextNode (text) { 25910 return document.createTextNode(text) 25911} 25912 25913function createComment (text) { 25914 return document.createComment(text) 25915} 25916 25917function insertBefore (parentNode, newNode, referenceNode) { 25918 parentNode.insertBefore(newNode, referenceNode); 25919} 25920 25921function removeChild (node, child) { 25922 node.removeChild(child); 25923} 25924 25925function appendChild (node, child) { 25926 node.appendChild(child); 25927} 25928 25929function parentNode (node) { 25930 return node.parentNode 25931} 25932 25933function nextSibling (node) { 25934 return node.nextSibling 25935} 25936 25937function tagName (node) { 25938 return node.tagName 25939} 25940 25941function setTextContent (node, text) { 25942 node.textContent = text; 25943} 25944 25945function setAttribute (node, key, val) { 25946 node.setAttribute(key, val); 25947} 25948 25949 25950var nodeOps = Object.freeze({ 25951 createElement: createElement$1, 25952 createElementNS: createElementNS, 25953 createTextNode: createTextNode, 25954 createComment: createComment, 25955 insertBefore: insertBefore, 25956 removeChild: removeChild, 25957 appendChild: appendChild, 25958 parentNode: parentNode, 25959 nextSibling: nextSibling, 25960 tagName: tagName, 25961 setTextContent: setTextContent, 25962 setAttribute: setAttribute 25963}); 25964 25965/* */ 25966 25967var ref = { 25968 create: function create (_, vnode) { 25969 registerRef(vnode); 25970 }, 25971 update: function update (oldVnode, vnode) { 25972 if (oldVnode.data.ref !== vnode.data.ref) { 25973 registerRef(oldVnode, true); 25974 registerRef(vnode); 25975 } 25976 }, 25977 destroy: function destroy (vnode) { 25978 registerRef(vnode, true); 25979 } 25980}; 25981 25982function registerRef (vnode, isRemoval) { 25983 var key = vnode.data.ref; 25984 if (!key) { return } 25985 25986 var vm = vnode.context; 25987 var ref = vnode.componentInstance || vnode.elm; 25988 var refs = vm.$refs; 25989 if (isRemoval) { 25990 if (Array.isArray(refs[key])) { 25991 remove(refs[key], ref); 25992 } else if (refs[key] === ref) { 25993 refs[key] = undefined; 25994 } 25995 } else { 25996 if (vnode.data.refInFor) { 25997 if (!Array.isArray(refs[key])) { 25998 refs[key] = [ref]; 25999 } else if (refs[key].indexOf(ref) < 0) { 26000 // $flow-disable-line 26001 refs[key].push(ref); 26002 } 26003 } else { 26004 refs[key] = ref; 26005 } 26006 } 26007} 26008 26009/** 26010 * Virtual DOM patching algorithm based on Snabbdom by 26011 * Simon Friis Vindum (@paldepind) 26012 * Licensed under the MIT License 26013 * https://github.com/paldepind/snabbdom/blob/master/LICENSE 26014 * 26015 * modified by Evan You (@yyx990803) 26016 * 26017 * Not type-checking this because this file is perf-critical and the cost 26018 * of making flow understand it is not worth it. 26019 */ 26020 26021var emptyNode = new VNode('', {}, []); 26022 26023var hooks = ['create', 'activate', 'update', 'remove', 'destroy']; 26024 26025function sameVnode (a, b) { 26026 return ( 26027 a.key === b.key && ( 26028 ( 26029 a.tag === b.tag && 26030 a.isComment === b.isComment && 26031 isDef(a.data) === isDef(b.data) && 26032 sameInputType(a, b) 26033 ) || ( 26034 isTrue(a.isAsyncPlaceholder) && 26035 a.asyncFactory === b.asyncFactory && 26036 isUndef(b.asyncFactory.error) 26037 ) 26038 ) 26039 ) 26040} 26041 26042function sameInputType (a, b) { 26043 if (a.tag !== 'input') { return true } 26044 var i; 26045 var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; 26046 var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; 26047 return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB) 26048} 26049 26050function createKeyToOldIdx (children, beginIdx, endIdx) { 26051 var i, key; 26052 var map = {}; 26053 for (i = beginIdx; i <= endIdx; ++i) { 26054 key = children[i].key; 26055 if (isDef(key)) { map[key] = i; } 26056 } 26057 return map 26058} 26059 26060function createPatchFunction (backend) { 26061 var i, j; 26062 var cbs = {}; 26063 26064 var modules = backend.modules; 26065 var nodeOps = backend.nodeOps; 26066 26067 for (i = 0; i < hooks.length; ++i) { 26068 cbs[hooks[i]] = []; 26069 for (j = 0; j < modules.length; ++j) { 26070 if (isDef(modules[j][hooks[i]])) { 26071 cbs[hooks[i]].push(modules[j][hooks[i]]); 26072 } 26073 } 26074 } 26075 26076 function emptyNodeAt (elm) { 26077 return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm) 26078 } 26079 26080 function createRmCb (childElm, listeners) { 26081 function remove () { 26082 if (--remove.listeners === 0) { 26083 removeNode(childElm); 26084 } 26085 } 26086 remove.listeners = listeners; 26087 return remove 26088 } 26089 26090 function removeNode (el) { 26091 var parent = nodeOps.parentNode(el); 26092 // element may have already been removed due to v-html / v-text 26093 if (isDef(parent)) { 26094 nodeOps.removeChild(parent, el); 26095 } 26096 } 26097 26098 function isUnknownElement$$1 (vnode, inVPre) { 26099 return ( 26100 !inVPre && 26101 !vnode.ns && 26102 !( 26103 config.ignoredElements.length && 26104 config.ignoredElements.some(function (ignore) { 26105 return isRegExp(ignore) 26106 ? ignore.test(vnode.tag) 26107 : ignore === vnode.tag 26108 }) 26109 ) && 26110 config.isUnknownElement(vnode.tag) 26111 ) 26112 } 26113 26114 var creatingElmInVPre = 0; 26115 function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) { 26116 vnode.isRootInsert = !nested; // for transition enter check 26117 if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { 26118 return 26119 } 26120 26121 var data = vnode.data; 26122 var children = vnode.children; 26123 var tag = vnode.tag; 26124 if (isDef(tag)) { 26125 { 26126 if (data && data.pre) { 26127 creatingElmInVPre++; 26128 } 26129 if (isUnknownElement$$1(vnode, creatingElmInVPre)) { 26130 warn( 26131 'Unknown custom element: <' + tag + '> - did you ' + 26132 'register the component correctly? For recursive components, ' + 26133 'make sure to provide the "name" option.', 26134 vnode.context 26135 ); 26136 } 26137 } 26138 vnode.elm = vnode.ns 26139 ? nodeOps.createElementNS(vnode.ns, tag) 26140 : nodeOps.createElement(tag, vnode); 26141 setScope(vnode); 26142 26143 /* istanbul ignore if */ 26144 { 26145 createChildren(vnode, children, insertedVnodeQueue); 26146 if (isDef(data)) { 26147 invokeCreateHooks(vnode, insertedVnodeQueue); 26148 } 26149 insert(parentElm, vnode.elm, refElm); 26150 } 26151 26152 if ("development" !== 'production' && data && data.pre) { 26153 creatingElmInVPre--; 26154 } 26155 } else if (isTrue(vnode.isComment)) { 26156 vnode.elm = nodeOps.createComment(vnode.text); 26157 insert(parentElm, vnode.elm, refElm); 26158 } else { 26159 vnode.elm = nodeOps.createTextNode(vnode.text); 26160 insert(parentElm, vnode.elm, refElm); 26161 } 26162 } 26163 26164 function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 26165 var i = vnode.data; 26166 if (isDef(i)) { 26167 var isReactivated = isDef(vnode.componentInstance) && i.keepAlive; 26168 if (isDef(i = i.hook) && isDef(i = i.init)) { 26169 i(vnode, false /* hydrating */, parentElm, refElm); 26170 } 26171 // after calling the init hook, if the vnode is a child component 26172 // it should've created a child instance and mounted it. the child 26173 // component also has set the placeholder vnode's elm. 26174 // in that case we can just return the element and be done.
vendor: 5,386 bytes, lines 26175-26341
26175 if (isDef(vnode.componentInstance)) { 26176 initComponent(vnode, insertedVnodeQueue); 26177 if (isTrue(isReactivated)) { 26178 reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); 26179 } 26180 return true 26181 } 26182 } 26183 } 26184 26185 function initComponent (vnode, insertedVnodeQueue) { 26186 if (isDef(vnode.data.pendingInsert)) { 26187 insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); 26188 vnode.data.pendingInsert = null; 26189 } 26190 vnode.elm = vnode.componentInstance.$el; 26191 if (isPatchable(vnode)) { 26192 invokeCreateHooks(vnode, insertedVnodeQueue); 26193 setScope(vnode); 26194 } else { 26195 // empty component root. 26196 // skip all element-related modules except for ref (#3455) 26197 registerRef(vnode); 26198 // make sure to invoke the insert hook 26199 insertedVnodeQueue.push(vnode); 26200 } 26201 } 26202 26203 function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 26204 var i; 26205 // hack for #4339: a reactivated component with inner transition 26206 // does not trigger because the inner node's created hooks are not called 26207 // again. It's not ideal to involve module-specific logic in here but 26208 // there doesn't seem to be a better way to do it. 26209 var innerNode = vnode; 26210 while (innerNode.componentInstance) { 26211 innerNode = innerNode.componentInstance._vnode; 26212 if (isDef(i = innerNode.data) && isDef(i = i.transition)) { 26213 for (i = 0; i < cbs.activate.length; ++i) { 26214 cbs.activate[i](emptyNode, innerNode); 26215 } 26216 insertedVnodeQueue.push(innerNode); 26217 break 26218 } 26219 } 26220 // unlike a newly created component, 26221 // a reactivated keep-alive component doesn't insert itself 26222 insert(parentElm, vnode.elm, refElm); 26223 } 26224 26225 function insert (parent, elm, ref$$1) { 26226 if (isDef(parent)) { 26227 if (isDef(ref$$1)) { 26228 if (ref$$1.parentNode === parent) { 26229 nodeOps.insertBefore(parent, elm, ref$$1); 26230 } 26231 } else { 26232 nodeOps.appendChild(parent, elm); 26233 } 26234 } 26235 } 26236 26237 function createChildren (vnode, children, insertedVnodeQueue) { 26238 if (Array.isArray(children)) { 26239 for (var i = 0; i < children.length; ++i) { 26240 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true); 26241 } 26242 } else if (isPrimitive(vnode.text)) { 26243 nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text)); 26244 } 26245 } 26246 26247 function isPatchable (vnode) { 26248 while (vnode.componentInstance) { 26249 vnode = vnode.componentInstance._vnode; 26250 } 26251 return isDef(vnode.tag) 26252 } 26253 26254 function invokeCreateHooks (vnode, insertedVnodeQueue) { 26255 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 26256 cbs.create[i$1](emptyNode, vnode); 26257 } 26258 i = vnode.data.hook; // Reuse variable 26259 if (isDef(i)) { 26260 if (isDef(i.create)) { i.create(emptyNode, vnode); } 26261 if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); } 26262 } 26263 } 26264 26265 // set scope id attribute for scoped CSS. 26266 // this is implemented as a special case to avoid the overhead 26267 // of going through the normal attribute patching process. 26268 function setScope (vnode) { 26269 var i; 26270 if (isDef(i = vnode.functionalScopeId)) { 26271 nodeOps.setAttribute(vnode.elm, i, ''); 26272 } else { 26273 var ancestor = vnode; 26274 while (ancestor) { 26275 if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) { 26276 nodeOps.setAttribute(vnode.elm, i, ''); 26277 } 26278 ancestor = ancestor.parent; 26279 } 26280 } 26281 // for slot content they should also get the scopeId from the host instance. 26282 if (isDef(i = activeInstance) && 26283 i !== vnode.context && 26284 i !== vnode.functionalContext && 26285 isDef(i = i.$options._scopeId) 26286 ) { 26287 nodeOps.setAttribute(vnode.elm, i, ''); 26288 } 26289 } 26290 26291 function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { 26292 for (; startIdx <= endIdx; ++startIdx) { 26293 createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm); 26294 } 26295 } 26296 26297 function invokeDestroyHook (vnode) { 26298 var i, j; 26299 var data = vnode.data; 26300 if (isDef(data)) { 26301 if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); } 26302 for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); } 26303 } 26304 if (isDef(i = vnode.children)) { 26305 for (j = 0; j < vnode.children.length; ++j) { 26306 invokeDestroyHook(vnode.children[j]); 26307 } 26308 } 26309 } 26310 26311 function removeVnodes (parentElm, vnodes, startIdx, endIdx) { 26312 for (; startIdx <= endIdx; ++startIdx) { 26313 var ch = vnodes[startIdx]; 26314 if (isDef(ch)) { 26315 if (isDef(ch.tag)) { 26316 removeAndInvokeRemoveHook(ch); 26317 invokeDestroyHook(ch); 26318 } else { // Text node 26319 removeNode(ch.elm); 26320 } 26321 } 26322 } 26323 } 26324 26325 function removeAndInvokeRemoveHook (vnode, rm) { 26326 if (isDef(rm) || isDef(vnode.data)) { 26327 var i; 26328 var listeners = cbs.remove.length + 1; 26329 if (isDef(rm)) { 26330 // we have a recursively passed down rm callback 26331 // increase the listeners count 26332 rm.listeners += listeners; 26333 } else { 26334 // directly removing 26335 rm = createRmCb(vnode.elm, listeners); 26336 } 26337 // recursively invoke hooks on child component root node 26338 if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) { 26339 removeAndInvokeRemoveHook(i, rm); 26340 } 26341 for (i = 0; i < cbs.remove.length; ++i) {
vendor: 8,821 bytes, lines 26342-26569
26342 cbs.remove[i](vnode, rm); 26343 } 26344 if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) { 26345 i(vnode, rm); 26346 } else { 26347 rm(); 26348 } 26349 } else { 26350 removeNode(vnode.elm); 26351 } 26352 } 26353 26354 function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { 26355 var oldStartIdx = 0; 26356 var newStartIdx = 0; 26357 var oldEndIdx = oldCh.length - 1; 26358 var oldStartVnode = oldCh[0]; 26359 var oldEndVnode = oldCh[oldEndIdx]; 26360 var newEndIdx = newCh.length - 1; 26361 var newStartVnode = newCh[0]; 26362 var newEndVnode = newCh[newEndIdx]; 26363 var oldKeyToIdx, idxInOld, vnodeToMove, refElm; 26364 26365 // removeOnly is a special flag used only by <transition-group> 26366 // to ensure removed elements stay in correct relative positions 26367 // during leaving transitions 26368 var canMove = !removeOnly; 26369 26370 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { 26371 if (isUndef(oldStartVnode)) { 26372 oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left 26373 } else if (isUndef(oldEndVnode)) { 26374 oldEndVnode = oldCh[--oldEndIdx]; 26375 } else if (sameVnode(oldStartVnode, newStartVnode)) { 26376 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue); 26377 oldStartVnode = oldCh[++oldStartIdx]; 26378 newStartVnode = newCh[++newStartIdx]; 26379 } else if (sameVnode(oldEndVnode, newEndVnode)) { 26380 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue); 26381 oldEndVnode = oldCh[--oldEndIdx]; 26382 newEndVnode = newCh[--newEndIdx]; 26383 } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right 26384 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); 26385 canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); 26386 oldStartVnode = oldCh[++oldStartIdx]; 26387 newEndVnode = newCh[--newEndIdx]; 26388 } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left 26389 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); 26390 canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); 26391 oldEndVnode = oldCh[--oldEndIdx]; 26392 newStartVnode = newCh[++newStartIdx]; 26393 } else { 26394 if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); } 26395 idxInOld = isDef(newStartVnode.key) 26396 ? oldKeyToIdx[newStartVnode.key] 26397 : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); 26398 if (isUndef(idxInOld)) { // New element 26399 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 26400 } else { 26401 vnodeToMove = oldCh[idxInOld]; 26402 /* istanbul ignore if */ 26403 if ("development" !== 'production' && !vnodeToMove) { 26404 warn( 26405 'It seems there are duplicate keys that is causing an update error. ' + 26406 'Make sure each v-for item has a unique key.' 26407 ); 26408 } 26409 if (sameVnode(vnodeToMove, newStartVnode)) { 26410 patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue); 26411 oldCh[idxInOld] = undefined; 26412 canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); 26413 } else { 26414 // same key but different element. treat as new element 26415 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm); 26416 } 26417 } 26418 newStartVnode = newCh[++newStartIdx]; 26419 } 26420 } 26421 if (oldStartIdx > oldEndIdx) { 26422 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; 26423 addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); 26424 } else if (newStartIdx > newEndIdx) { 26425 removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); 26426 } 26427 } 26428 26429 function findIdxInOld (node, oldCh, start, end) { 26430 for (var i = start; i < end; i++) { 26431 var c = oldCh[i]; 26432 if (isDef(c) && sameVnode(node, c)) { return i } 26433 } 26434 } 26435 26436 function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) { 26437 if (oldVnode === vnode) { 26438 return 26439 } 26440 26441 var elm = vnode.elm = oldVnode.elm; 26442 26443 if (isTrue(oldVnode.isAsyncPlaceholder)) { 26444 if (isDef(vnode.asyncFactory.resolved)) { 26445 hydrate(oldVnode.elm, vnode, insertedVnodeQueue); 26446 } else { 26447 vnode.isAsyncPlaceholder = true; 26448 } 26449 return 26450 } 26451 26452 // reuse element for static trees. 26453 // note we only do this if the vnode is cloned - 26454 // if the new node is not cloned it means the render functions have been 26455 // reset by the hot-reload-api and we need to do a proper re-render. 26456 if (isTrue(vnode.isStatic) && 26457 isTrue(oldVnode.isStatic) && 26458 vnode.key === oldVnode.key && 26459 (isTrue(vnode.isCloned) || isTrue(vnode.isOnce)) 26460 ) { 26461 vnode.componentInstance = oldVnode.componentInstance; 26462 return 26463 } 26464 26465 var i; 26466 var data = vnode.data; 26467 if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) { 26468 i(oldVnode, vnode); 26469 } 26470 26471 var oldCh = oldVnode.children; 26472 var ch = vnode.children; 26473 if (isDef(data) && isPatchable(vnode)) { 26474 for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); } 26475 if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); } 26476 } 26477 if (isUndef(vnode.text)) { 26478 if (isDef(oldCh) && isDef(ch)) { 26479 if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); } 26480 } else if (isDef(ch)) { 26481 if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); } 26482 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); 26483 } else if (isDef(oldCh)) { 26484 removeVnodes(elm, oldCh, 0, oldCh.length - 1); 26485 } else if (isDef(oldVnode.text)) { 26486 nodeOps.setTextContent(elm, ''); 26487 } 26488 } else if (oldVnode.text !== vnode.text) { 26489 nodeOps.setTextContent(elm, vnode.text); 26490 } 26491 if (isDef(data)) { 26492 if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); } 26493 } 26494 } 26495 26496 function invokeInsertHook (vnode, queue, initial) { 26497 // delay insert hooks for component root nodes, invoke them after the 26498 // element is really inserted 26499 if (isTrue(initial) && isDef(vnode.parent)) { 26500 vnode.parent.data.pendingInsert = queue; 26501 } else { 26502 for (var i = 0; i < queue.length; ++i) { 26503 queue[i].data.hook.insert(queue[i]); 26504 } 26505 } 26506 } 26507 26508 var hydrationBailed = false; 26509 // list of modules that can skip create hook during hydration because they 26510 // are already rendered on the client or has no need for initialization 26511 // Note: style is excluded because it relies on initial clone for future 26512 // deep updates (#7063). 26513 var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key'); 26514 26515 // Note: this is a browser-only function so we can assume elms are DOM nodes. 26516 function hydrate (elm, vnode, insertedVnodeQueue, inVPre) { 26517 var i; 26518 var tag = vnode.tag; 26519 var data = vnode.data; 26520 var children = vnode.children; 26521 inVPre = inVPre || (data && data.pre); 26522 vnode.elm = elm; 26523 26524 if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { 26525 vnode.isAsyncPlaceholder = true; 26526 return true 26527 } 26528 // assert node match 26529 { 26530 if (!assertNodeMatch(elm, vnode, inVPre)) { 26531 return false 26532 } 26533 } 26534 if (isDef(data)) { 26535 if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); } 26536 if (isDef(i = vnode.componentInstance)) { 26537 // child component. it should have hydrated its own tree. 26538 initComponent(vnode, insertedVnodeQueue); 26539 return true 26540 } 26541 } 26542 if (isDef(tag)) { 26543 if (isDef(children)) { 26544 // empty element, allow client to pick up and populate children 26545 if (!elm.hasChildNodes()) { 26546 createChildren(vnode, children, insertedVnodeQueue); 26547 } else { 26548 // v-html and domProps: innerHTML 26549 if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) { 26550 if (i !== elm.innerHTML) { 26551 /* istanbul ignore if */ 26552 if ("development" !== 'production' && 26553 typeof console !== 'undefined' && 26554 !hydrationBailed 26555 ) { 26556 hydrationBailed = true; 26557 console.warn('Parent: ', elm); 26558 console.warn('server innerHTML: ', i); 26559 console.warn('client innerHTML: ', elm.innerHTML); 26560 } 26561 return false 26562 } 26563 } else { 26564 // iterate and compare children lists 26565 var childrenMatch = true; 26566 var childNode = elm.firstChild; 26567 for (var i$1 = 0; i$1 < children.length; i$1++) { 26568 if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) { 26569 childrenMatch = false;
26570 break 26571 } 26572 childNode = childNode.nextSibling; 26573 } 26574 // if childNode is not null, it means the actual childNodes list is 26575 // longer than the virtual children list. 26576 if (!childrenMatch || childNode) { 26577 /* istanbul ignore if */ 26578 if ("development" !== 'production' && 26579 typeof console !== 'undefined' && 26580 !hydrationBailed 26581 ) { 26582 hydrationBailed = true; 26583 console.warn('Parent: ', elm); 26584 console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children); 26585 } 26586 return false 26587 } 26588 } 26589 } 26590 } 26591 if (isDef(data)) { 26592 var fullInvoke = false; 26593 for (var key in data) { 26594 if (!isRenderedModule(key)) { 26595 fullInvoke = true; 26596 invokeCreateHooks(vnode, insertedVnodeQueue); 26597 break 26598 } 26599 } 26600 if (!fullInvoke && data['class']) { 26601 // ensure collecting deps for deep class bindings for future updates 26602 traverse(data['class']); 26603 } 26604 } 26605 } else if (elm.data !== vnode.text) { 26606 elm.data = vnode.text; 26607 } 26608 return true 26609 } 26610 26611 function assertNodeMatch (node, vnode, inVPre) {
26612 if (isDef(vnode.tag)) { 26613 return vnode.tag.indexOf('vue-component') === 0 || ( 26614 !isUnknownElement$$1(vnode, inVPre) && 26615 vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()) 26616 ) 26617 } else { 26618 return node.nodeType === (vnode.isComment ? 8 : 3) 26619 } 26620 } 26621 26622 return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) { 26623 if (isUndef(vnode)) { 26624 if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); } 26625 return 26626 } 26627 26628 var isInitialPatch = false; 26629 var insertedVnodeQueue = []; 26630 26631 if (isUndef(oldVnode)) { 26632 // empty mount (likely as component), create new root element 26633 isInitialPatch = true; 26634 createElm(vnode, insertedVnodeQueue, parentElm, refElm); 26635 } else { 26636 var isRealElement = isDef(oldVnode.nodeType); 26637 if (!isRealElement && sameVnode(oldVnode, vnode)) { 26638 // patch existing root node 26639 patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly); 26640 } else { 26641 if (isRealElement) { 26642 // mounting to a real element 26643 // check if this is server-rendered content and if we can perform 26644 // a successful hydration. 26645 if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { 26646 oldVnode.removeAttribute(SSR_ATTR); 26647 hydrating = true; 26648 } 26649 if (isTrue(hydrating)) { 26650 if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { 26651 invokeInsertHook(vnode, insertedVnodeQueue, true); 26652 return oldVnode 26653 } else { 26654 warn( 26655 'The client-side rendered virtual DOM tree is not matching ' + 26656 'server-rendered content. This is likely caused by incorrect ' + 26657 'HTML markup, for example nesting block-level elements inside ' + 26658 '<p>, or missing <tbody>. Bailing hydration and performing ' + 26659 'full client-side render.' 26660 ); 26661 } 26662 } 26663 // either not server-rendered, or hydration failed. 26664 // create an empty node and replace it 26665 oldVnode = emptyNodeAt(oldVnode); 26666 } 26667 26668 // replacing existing element 26669 var oldElm = oldVnode.elm; 26670 var parentElm$1 = nodeOps.parentNode(oldElm); 26671 26672 // create new node 26673 createElm( 26674 vnode, 26675 insertedVnodeQueue, 26676 // extremely rare edge case: do not insert if old element is in a 26677 // leaving transition. Only happens when combining transition + 26678 // keep-alive + HOCs. (#4590) 26679 oldElm._leaveCb ? null : parentElm$1, 26680 nodeOps.nextSibling(oldElm) 26681 ); 26682 26683 // update parent placeholder node element, recursively
vendor: 5,863 bytes, lines 26684-26898
26684 if (isDef(vnode.parent)) { 26685 var ancestor = vnode.parent; 26686 var patchable = isPatchable(vnode); 26687 while (ancestor) { 26688 for (var i = 0; i < cbs.destroy.length; ++i) { 26689 cbs.destroy[i](ancestor); 26690 } 26691 ancestor.elm = vnode.elm; 26692 if (patchable) { 26693 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 26694 cbs.create[i$1](emptyNode, ancestor); 26695 } 26696 // #6513 26697 // invoke insert hooks that may have been merged by create hooks. 26698 // e.g. for directives that uses the "inserted" hook. 26699 var insert = ancestor.data.hook.insert; 26700 if (insert.merged) { 26701 // start at index 1 to avoid re-invoking component mounted hook 26702 for (var i$2 = 1; i$2 < insert.fns.length; i$2++) { 26703 insert.fns[i$2](); 26704 } 26705 } 26706 } else { 26707 registerRef(ancestor); 26708 } 26709 ancestor = ancestor.parent; 26710 } 26711 } 26712 26713 // destroy old node 26714 if (isDef(parentElm$1)) { 26715 removeVnodes(parentElm$1, [oldVnode], 0, 0); 26716 } else if (isDef(oldVnode.tag)) { 26717 invokeDestroyHook(oldVnode); 26718 } 26719 } 26720 } 26721 26722 invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); 26723 return vnode.elm 26724 } 26725} 26726 26727/* */ 26728 26729var directives = { 26730 create: updateDirectives, 26731 update: updateDirectives, 26732 destroy: function unbindDirectives (vnode) { 26733 updateDirectives(vnode, emptyNode); 26734 } 26735}; 26736 26737function updateDirectives (oldVnode, vnode) { 26738 if (oldVnode.data.directives || vnode.data.directives) { 26739 _update(oldVnode, vnode); 26740 } 26741} 26742 26743function _update (oldVnode, vnode) { 26744 var isCreate = oldVnode === emptyNode; 26745 var isDestroy = vnode === emptyNode; 26746 var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); 26747 var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); 26748 26749 var dirsWithInsert = []; 26750 var dirsWithPostpatch = []; 26751 26752 var key, oldDir, dir; 26753 for (key in newDirs) { 26754 oldDir = oldDirs[key]; 26755 dir = newDirs[key]; 26756 if (!oldDir) { 26757 // new directive, bind 26758 callHook$1(dir, 'bind', vnode, oldVnode); 26759 if (dir.def && dir.def.inserted) { 26760 dirsWithInsert.push(dir); 26761 } 26762 } else { 26763 // existing directive, update 26764 dir.oldValue = oldDir.value; 26765 callHook$1(dir, 'update', vnode, oldVnode); 26766 if (dir.def && dir.def.componentUpdated) { 26767 dirsWithPostpatch.push(dir); 26768 } 26769 } 26770 } 26771 26772 if (dirsWithInsert.length) { 26773 var callInsert = function () { 26774 for (var i = 0; i < dirsWithInsert.length; i++) { 26775 callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); 26776 } 26777 }; 26778 if (isCreate) { 26779 mergeVNodeHook(vnode, 'insert', callInsert); 26780 } else { 26781 callInsert(); 26782 } 26783 } 26784 26785 if (dirsWithPostpatch.length) { 26786 mergeVNodeHook(vnode, 'postpatch', function () { 26787 for (var i = 0; i < dirsWithPostpatch.length; i++) { 26788 callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); 26789 } 26790 }); 26791 } 26792 26793 if (!isCreate) { 26794 for (key in oldDirs) { 26795 if (!newDirs[key]) { 26796 // no longer present, unbind 26797 callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); 26798 } 26799 } 26800 } 26801} 26802 26803var emptyModifiers = Object.create(null); 26804 26805function normalizeDirectives$1 ( 26806 dirs, 26807 vm 26808) { 26809 var res = Object.create(null); 26810 if (!dirs) { 26811 return res 26812 } 26813 var i, dir; 26814 for (i = 0; i < dirs.length; i++) { 26815 dir = dirs[i]; 26816 if (!dir.modifiers) { 26817 dir.modifiers = emptyModifiers; 26818 } 26819 res[getRawDirName(dir)] = dir; 26820 dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); 26821 } 26822 return res 26823} 26824 26825function getRawDirName (dir) { 26826 return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) 26827} 26828 26829function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { 26830 var fn = dir.def && dir.def[hook]; 26831 if (fn) { 26832 try { 26833 fn(vnode.elm, dir, vnode, oldVnode, isDestroy); 26834 } catch (e) { 26835 handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook")); 26836 } 26837 } 26838} 26839 26840var baseModules = [ 26841 ref, 26842 directives 26843]; 26844 26845/* */ 26846 26847function updateAttrs (oldVnode, vnode) { 26848 var opts = vnode.componentOptions; 26849 if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { 26850 return 26851 } 26852 if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { 26853 return 26854 } 26855 var key, cur, old; 26856 var elm = vnode.elm; 26857 var oldAttrs = oldVnode.data.attrs || {}; 26858 var attrs = vnode.data.attrs || {}; 26859 // clone observed objects, as the user probably wants to mutate it 26860 if (isDef(attrs.__ob__)) { 26861 attrs = vnode.data.attrs = extend({}, attrs); 26862 } 26863 26864 for (key in attrs) { 26865 cur = attrs[key]; 26866 old = oldAttrs[key]; 26867 if (old !== cur) { 26868 setAttr(elm, key, cur); 26869 } 26870 } 26871 // #4391: in IE9, setting type can reset value for input[type=radio] 26872 // #6666: IE/Edge forces progress value down to 1 before setting a max 26873 /* istanbul ignore if */ 26874 if ((isIE9 || isEdge) && attrs.value !== oldAttrs.value) { 26875 setAttr(elm, 'value', attrs.value); 26876 } 26877 for (key in oldAttrs) { 26878 if (isUndef(attrs[key])) { 26879 if (isXlink(key)) { 26880 elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); 26881 } else if (!isEnumeratedAttr(key)) { 26882 elm.removeAttribute(key); 26883 } 26884 } 26885 } 26886} 26887 26888function setAttr (el, key, value) { 26889 if (isBooleanAttr(key)) { 26890 // set attribute for blank value 26891 // e.g. <option disabled>Select one</option> 26892 if (isFalsyAttrValue(value)) { 26893 el.removeAttribute(key); 26894 } else { 26895 // technically allowfullscreen is a boolean attribute for <iframe>, 26896 // but Flash expects a value of "true" when used on <embed> tag 26897 value = key === 'allowfullscreen' && el.tagName === 'EMBED' 26898 ? 'true'
26899 : key; 26900 el.setAttribute(key, value); 26901 } 26902 } else if (isEnumeratedAttr(key)) { 26903 el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true'); 26904 } else if (isXlink(key)) { 26905 if (isFalsyAttrValue(value)) { 26906 el.removeAttributeNS(xlinkNS, getXlinkProp(key)); 26907 } else { 26908 el.setAttributeNS(xlinkNS, key, value); 26909 } 26910 } else { 26911 if (isFalsyAttrValue(value)) { 26912 el.removeAttribute(key); 26913 } else { 26914 el.setAttribute(key, value); 26915 } 26916 } 26917} 26918 26919var attrs = { 26920 create: updateAttrs, 26921 update: updateAttrs 26922}; 26923 26924/* */ 26925 26926function updateClass (oldVnode, vnode) { 26927 var el = vnode.elm; 26928 var data = vnode.data; 26929 var oldData = oldVnode.data; 26930 if ( 26931 isUndef(data.staticClass) && 26932 isUndef(data.class) && ( 26933 isUndef(oldData) || ( 26934 isUndef(oldData.staticClass) && 26935 isUndef(oldData.class) 26936 ) 26937 ) 26938 ) { 26939 return 26940 } 26941 26942 var cls = genClassForVnode(vnode); 26943 26944 // handle transition classes 26945 var transitionClass = el._transitionClasses; 26946 if (isDef(transitionClass)) { 26947 cls = concat(cls, stringifyClass(transitionClass)); 26948 } 26949 26950 // set the class 26951 if (cls !== el._prevClass) { 26952 el.setAttribute('class', cls); 26953 el._prevClass = cls; 26954 } 26955} 26956 26957var klass = { 26958 create: updateClass, 26959 update: updateClass 26960}; 26961 26962/* */ 26963 26964var validDivisionCharRE = /[\w).+\-_$\]]/; 26965 26966function parseFilters (exp) { 26967 var inSingle = false; 26968 var inDouble = false; 26969 var inTemplateString = false; 26970 var inRegex = false; 26971 var curly = 0; 26972 var square = 0; 26973 var paren = 0; 26974 var lastFilterIndex = 0; 26975 var c, prev, i, expression, filters; 26976 26977 for (i = 0; i < exp.length; i++) { 26978 prev = c; 26979 c = exp.charCodeAt(i); 26980 if (inSingle) { 26981 if (c === 0x27 && prev !== 0x5C) { inSingle = false; } 26982 } else if (inDouble) { 26983 if (c === 0x22 && prev !== 0x5C) { inDouble = false; } 26984 } else if (inTemplateString) { 26985 if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; } 26986 } else if (inRegex) { 26987 if (c === 0x2f && prev !== 0x5C) { inRegex = false; } 26988 } else if ( 26989 c === 0x7C && // pipe 26990 exp.charCodeAt(i + 1) !== 0x7C && 26991 exp.charCodeAt(i - 1) !== 0x7C && 26992 !curly && !square && !paren 26993 ) { 26994 if (expression === undefined) { 26995 // first filter, end of expression 26996 lastFilterIndex = i + 1; 26997 expression = exp.slice(0, i).trim(); 26998 } else { 26999 pushFilter(); 27000 } 27001 } else { 27002 switch (c) { 27003 case 0x22: inDouble = true; break // " 27004 case 0x27: inSingle = true; break // ' 27005 case 0x60: inTemplateString = true; break // ` 27006 case 0x28: paren++; break // ( 27007 case 0x29: paren--; break // ) 27008 case 0x5B: square++; break // [ 27009 case 0x5D: square--; break // ] 27010 case 0x7B: curly++; break // { 27011 case 0x7D: curly--; break // } 27012 } 27013 if (c === 0x2f) { // / 27014 var j = i - 1; 27015 var p = (void 0); 27016 // find first non-whitespace prev char 27017 for (; j >= 0; j--) { 27018 p = exp.charAt(j); 27019 if (p !== ' ') { break } 27020 } 27021 if (!p || !validDivisionCharRE.test(p)) { 27022 inRegex = true; 27023 } 27024 } 27025 } 27026 } 27027 27028 if (expression === undefined) { 27029 expression = exp.slice(0, i).trim(); 27030 } else if (lastFilterIndex !== 0) { 27031 pushFilter(); 27032 } 27033 27034 function pushFilter () { 27035 (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); 27036 lastFilterIndex = i + 1; 27037 } 27038 27039 if (filters) { 27040 for (i = 0; i < filters.length; i++) { 27041 expression = wrapFilter(expression, filters[i]); 27042 } 27043 } 27044 27045 return expression 27046} 27047 27048function wrapFilter (exp, filter) { 27049 var i = filter.indexOf('('); 27050 if (i < 0) { 27051 // _f: resolveFilter 27052 return ("_f(\"" + filter + "\")(" + exp + ")") 27053 } else { 27054 var name = filter.slice(0, i); 27055 var args = filter.slice(i + 1); 27056 return ("_f(\"" + name + "\")(" + exp + "," + args) 27057 } 27058} 27059 27060/* */ 27061 27062function baseWarn (msg) { 27063 console.error(("[Vue compiler]: " + msg)); 27064} 27065 27066function pluckModuleFunction ( 27067 modules, 27068 key 27069) { 27070 return modules 27071 ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) 27072 : [] 27073} 27074 27075function addProp (el, name, value) { 27076 (el.props || (el.props = [])).push({ name: name, value: value }); 27077} 27078 27079function addAttr (el, name, value) { 27080 (el.attrs || (el.attrs = [])).push({ name: name, value: value }); 27081} 27082 27083function addDirective ( 27084 el, 27085 name, 27086 rawName, 27087 value, 27088 arg, 27089 modifiers 27090) { 27091 (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers }); 27092} 27093 27094function addHandler ( 27095 el, 27096 name, 27097 value, 27098 modifiers, 27099 important, 27100 warn 27101) { 27102 modifiers = modifiers || emptyObject; 27103 // warn prevent and passive modifier 27104 /* istanbul ignore if */ 27105 if ( 27106 "development" !== 'production' && warn && 27107 modifiers.prevent && modifiers.passive 27108 ) { 27109 warn( 27110 'passive and prevent can\'t be used together. ' + 27111 'Passive handler can\'t prevent default event.' 27112 ); 27113 } 27114 27115 // check capture modifier 27116 if (modifiers.capture) { 27117 delete modifiers.capture; 27118 name = '!' + name; // mark the event as captured 27119 } 27120 if (modifiers.once) { 27121 delete modifiers.once; 27122 name = '~' + name; // mark the event as once 27123 } 27124 /* istanbul ignore if */ 27125 if (modifiers.passive) { 27126 delete modifiers.passive; 27127 name = '&' + name; // mark the event as passive 27128 } 27129 27130 // normalize click.right and click.middle since they don't actually fire 27131 // this is technically browser-specific, but at least for now browsers are 27132 // the only target envs that have right/middle clicks.
27133 if (name === 'click') { 27134 if (modifiers.right) { 27135 name = 'contextmenu'; 27136 delete modifiers.right; 27137 } else if (modifiers.middle) { 27138 name = 'mouseup'; 27139 } 27140 } 27141 27142 var events; 27143 if (modifiers.native) { 27144 delete modifiers.native; 27145 events = el.nativeEvents || (el.nativeEvents = {}); 27146 } else { 27147 events = el.events || (el.events = {}); 27148 } 27149 27150 var newHandler = { value: value }; 27151 if (modifiers !== emptyObject) { 27152 newHandler.modifiers = modifiers; 27153 } 27154 27155 var handlers = events[name]; 27156 /* istanbul ignore if */ 27157 if (Array.isArray(handlers)) { 27158 important ? handlers.unshift(newHandler) : handlers.push(newHandler); 27159 } else if (handlers) { 27160 events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; 27161 } else { 27162 events[name] = newHandler; 27163 } 27164} 27165 27166function getBindingAttr ( 27167 el, 27168 name, 27169 getStatic 27170) { 27171 var dynamicValue = 27172 getAndRemoveAttr(el, ':' + name) || 27173 getAndRemoveAttr(el, 'v-bind:' + name); 27174 if (dynamicValue != null) { 27175 return parseFilters(dynamicValue) 27176 } else if (getStatic !== false) { 27177 var staticValue = getAndRemoveAttr(el, name); 27178 if (staticValue != null) { 27179 return JSON.stringify(staticValue) 27180 } 27181 } 27182} 27183 27184// note: this only removes the attr from the Array (attrsList) so that it 27185// doesn't get processed by processAttrs. 27186// By default it does NOT remove it from the map (attrsMap) because the map is 27187// needed during codegen. 27188function getAndRemoveAttr ( 27189 el, 27190 name, 27191 removeFromMap 27192) { 27193 var val; 27194 if ((val = el.attrsMap[name]) != null) { 27195 var list = el.attrsList; 27196 for (var i = 0, l = list.length; i < l; i++) { 27197 if (list[i].name === name) { 27198 list.splice(i, 1); 27199 break 27200 } 27201 } 27202 } 27203 if (removeFromMap) { 27204 delete el.attrsMap[name]; 27205 } 27206 return val 27207} 27208 27209/* */ 27210 27211/** 27212 * Cross-platform code generation for component v-model 27213 */ 27214function genComponentModel ( 27215 el, 27216 value, 27217 modifiers 27218) { 27219 var ref = modifiers || {}; 27220 var number = ref.number; 27221 var trim = ref.trim; 27222 27223 var baseValueExpression = '$$v'; 27224 var valueExpression = baseValueExpression; 27225 if (trim) { 27226 valueExpression = 27227 "(typeof " + baseValueExpression + " === 'string'" + 27228 "? " + baseValueExpression + ".trim()" + 27229 ": " + baseValueExpression + ")"; 27230 } 27231 if (number) { 27232 valueExpression = "_n(" + valueExpression + ")"; 27233 } 27234 var assignment = genAssignmentCode(value, valueExpression); 27235 27236 el.model = { 27237 value: ("(" + value + ")"), 27238 expression: ("\"" + value + "\""), 27239 callback: ("function (" + baseValueExpression + ") {" + assignment + "}") 27240 }; 27241} 27242 27243/** 27244 * Cross-platform codegen helper for generating v-model value assignment code. 27245 */ 27246function genAssignmentCode ( 27247 value, 27248 assignment 27249) { 27250 var res = parseModel(value); 27251 if (res.key === null) { 27252 return (value + "=" + assignment) 27253 } else { 27254 return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")") 27255 } 27256} 27257 27258/** 27259 * Parse a v-model expression into a base path and a final key segment. 27260 * Handles both dot-path and possible square brackets. 27261 * 27262 * Possible cases: 27263 * 27264 * - test 27265 * - test[key] 27266 * - test[test1[key]] 27267 * - test["a"][key] 27268 * - xxx.test[a[a].test1[key]] 27269 * - test.xxx.a["asa"][test1[key]] 27270 * 27271 */ 27272 27273var len; 27274var str; 27275var chr; 27276var index$1; 27277var expressionPos; 27278var expressionEndPos; 27279 27280 27281 27282function parseModel (val) { 27283 len = val.length; 27284 27285 if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { 27286 index$1 = val.lastIndexOf('.'); 27287 if (index$1 > -1) { 27288 return { 27289 exp: val.slice(0, index$1), 27290 key: '"' + val.slice(index$1 + 1) + '"' 27291 } 27292 } else { 27293 return { 27294 exp: val, 27295 key: null 27296 } 27297 } 27298 } 27299 27300 str = val; 27301 index$1 = expressionPos = expressionEndPos = 0; 27302 27303 while (!eof()) { 27304 chr = next(); 27305 /* istanbul ignore if */ 27306 if (isStringStart(chr)) { 27307 parseString(chr); 27308 } else if (chr === 0x5B) { 27309 parseBracket(chr); 27310 } 27311 } 27312 27313 return { 27314 exp: val.slice(0, expressionPos), 27315 key: val.slice(expressionPos + 1, expressionEndPos) 27316 } 27317} 27318 27319function next () { 27320 return str.charCodeAt(++index$1) 27321} 27322 27323function eof () { 27324 return index$1 >= len 27325} 27326 27327function isStringStart (chr) { 27328 return chr === 0x22 || chr === 0x27 27329} 27330 27331function parseBracket (chr) { 27332 var inBracket = 1; 27333 expressionPos = index$1; 27334 while (!eof()) { 27335 chr = next(); 27336 if (isStringStart(chr)) { 27337 parseString(chr); 27338 continue 27339 } 27340 if (chr === 0x5B) { inBracket++; } 27341 if (chr === 0x5D) { inBracket--; } 27342 if (inBracket === 0) { 27343 expressionEndPos = index$1; 27344 break 27345 } 27346 } 27347} 27348 27349function parseString (chr) { 27350 var stringQuote = chr; 27351 while (!eof()) { 27352 chr = next(); 27353 if (chr === stringQuote) { 27354 break 27355 } 27356 } 27357} 27358 27359/* */ 27360 27361var warn$1; 27362 27363// in some cases, the event used has to be determined at runtime 27364// so we used some reserved tokens during compile. 27365var RANGE_TOKEN = '__r'; 27366var CHECKBOX_RADIO_TOKEN = '__c'; 27367 27368function model ( 27369 el, 27370 dir, 27371 _warn 27372) { 27373 warn$1 = _warn; 27374 var value = dir.value; 27375 var modifiers = dir.modifiers; 27376 var tag = el.tag; 27377 var type = el.attrsMap.type; 27378 27379 { 27380 // inputs with type="file" are read only and setting the input's 27381 // value will throw an error. 27382 if (tag === 'input' && type === 'file') { 27383 warn$1( 27384 "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" + 27385 "File inputs are read only. Use a v-on:change listener instead." 27386 ); 27387 } 27388 } 27389 27390 if (el.component) { 27391 genComponentModel(el, value, modifiers); 27392 // component v-model doesn't need extra runtime 27393 return false 27394 } else if (tag === 'select') { 27395 genSelect(el, value, modifiers); 27396 } else if (tag === 'input' && type === 'checkbox') {
27397 genCheckboxModel(el, value, modifiers); 27398 } else if (tag === 'input' && type === 'radio') { 27399 genRadioModel(el, value, modifiers); 27400 } else if (tag === 'input' || tag === 'textarea') { 27401 genDefaultModel(el, value, modifiers); 27402 } else if (!config.isReservedTag(tag)) { 27403 genComponentModel(el, value, modifiers); 27404 // component v-model doesn't need extra runtime 27405 return false 27406 } else { 27407 warn$1( 27408 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 27409 "v-model is not supported on this element type. " + 27410 'If you are working with contenteditable, it\'s recommended to ' + 27411 'wrap a library dedicated for that purpose inside a custom component.' 27412 ); 27413 } 27414 27415 // ensure runtime directive metadata 27416 return true 27417} 27418 27419function genCheckboxModel ( 27420 el, 27421 value, 27422 modifiers 27423) { 27424 var number = modifiers && modifiers.number; 27425 var valueBinding = getBindingAttr(el, 'value') || 'null'; 27426 var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; 27427 var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; 27428 addProp(el, 'checked', 27429 "Array.isArray(" + value + ")" + 27430 "?_i(" + value + "," + valueBinding + ")>-1" + ( 27431 trueValueBinding === 'true' 27432 ? (":(" + value + ")") 27433 : (":_q(" + value + "," + trueValueBinding + ")") 27434 ) 27435 ); 27436 addHandler(el, 'change', 27437 "var $$a=" + value + "," + 27438 '$$el=$event.target,' + 27439 "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" + 27440 'if(Array.isArray($$a)){' + 27441 "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," + 27442 '$$i=_i($$a,$$v);' + 27443 "if($$el.checked){$$i<0&&(" + value + "=$$a.concat([$$v]))}" + 27444 "else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" + 27445 "}else{" + (genAssignmentCode(value, '$$c')) + "}", 27446 null, true 27447 ); 27448} 27449 27450function genRadioModel ( 27451 el, 27452 value, 27453 modifiers 27454) { 27455 var number = modifiers && modifiers.number; 27456 var valueBinding = getBindingAttr(el, 'value') || 'null'; 27457 valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding; 27458 addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")")); 27459 addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); 27460} 27461 27462function genSelect ( 27463 el, 27464 value, 27465 modifiers 27466) { 27467 var number = modifiers && modifiers.number; 27468 var selectedVal = "Array.prototype.filter" + 27469 ".call($event.target.options,function(o){return o.selected})" + 27470 ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" + 27471 "return " + (number ? '_n(val)' : 'val') + "})"; 27472 27473 var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; 27474 var code = "var $$selectedVal = " + selectedVal + ";"; 27475 code = code + " " + (genAssignmentCode(value, assignment)); 27476 addHandler(el, 'change', code, null, true); 27477} 27478 27479function genDefaultModel ( 27480 el, 27481 value, 27482 modifiers 27483) { 27484 var type = el.attrsMap.type; 27485 27486 // warn if v-bind:value conflicts with v-model 27487 { 27488 var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']; 27489 if (value$1) { 27490 var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'; 27491 warn$1( 27492 binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " + 27493 'because the latter already expands to a value binding internally' 27494 ); 27495 } 27496 } 27497 27498 var ref = modifiers || {}; 27499 var lazy = ref.lazy; 27500 var number = ref.number; 27501 var trim = ref.trim; 27502 var needCompositionGuard = !lazy && type !== 'range'; 27503 var event = lazy 27504 ? 'change' 27505 : type === 'range' 27506 ? RANGE_TOKEN 27507 : 'input'; 27508 27509 var valueExpression = '$event.target.value'; 27510 if (trim) { 27511 valueExpression = "$event.target.value.trim()"; 27512 } 27513 if (number) { 27514 valueExpression = "_n(" + valueExpression + ")"; 27515 } 27516 27517 var code = genAssignmentCode(value, valueExpression); 27518 if (needCompositionGuard) { 27519 code = "if($event.target.composing)return;" + code; 27520 } 27521 27522 addProp(el, 'value', ("(" + value + ")")); 27523 addHandler(el, event, code, null, true); 27524 if (trim || number) { 27525 addHandler(el, 'blur', '$forceUpdate()'); 27526 } 27527} 27528 27529/* */ 27530 27531// normalize v-model event tokens that can only be determined at runtime. 27532// it's important to place the event as the first in the array because 27533// the whole point is ensuring the v-model callback gets called before 27534// user-attached handlers. 27535function normalizeEvents (on) { 27536 /* istanbul ignore if */ 27537 if (isDef(on[RANGE_TOKEN])) { 27538 // IE input[type=range] only supports `change` event 27539 var event = isIE ? 'change' : 'input'; 27540 on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); 27541 delete on[RANGE_TOKEN]; 27542 } 27543 // This was originally intended to fix #4521 but no longer necessary 27544 // after 2.5. Keeping it for backwards compat with generated code from < 2.4 27545 /* istanbul ignore if */ 27546 if (isDef(on[CHECKBOX_RADIO_TOKEN])) { 27547 on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []); 27548 delete on[CHECKBOX_RADIO_TOKEN]; 27549 } 27550} 27551 27552var target$1; 27553 27554function createOnceHandler (handler, event, capture) { 27555 var _target = target$1; // save current target element in closure 27556 return function onceHandler () { 27557 var res = handler.apply(null, arguments); 27558 if (res !== null) { 27559 remove$2(event, onceHandler, capture, _target); 27560 } 27561 } 27562} 27563 27564function add$1 ( 27565 event, 27566 handler, 27567 once$$1, 27568 capture, 27569 passive 27570) { 27571 handler = withMacroTask(handler); 27572 if (once$$1) { handler = createOnceHandler(handler, event, capture); } 27573 target$1.addEventListener( 27574 event, 27575 handler, 27576 supportsPassive 27577 ? { capture: capture, passive: passive } 27578 : capture 27579 ); 27580} 27581 27582function remove$2 ( 27583 event, 27584 handler, 27585 capture, 27586 _target 27587) { 27588 (_target || target$1).removeEventListener( 27589 event, 27590 handler._withTask || handler, 27591 capture 27592 ); 27593} 27594 27595function updateDOMListeners (oldVnode, vnode) { 27596 if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { 27597 return 27598 } 27599 var on = vnode.data.on || {}; 27600 var oldOn = oldVnode.data.on || {}; 27601 target$1 = vnode.elm; 27602 normalizeEvents(on); 27603 updateListeners(on, oldOn, add$1, remove$2, vnode.context); 27604 target$1 = undefined; 27605} 27606 27607var events = { 27608 create: updateDOMListeners, 27609 update: updateDOMListeners 27610}; 27611 27612/* */ 27613 27614function updateDOMProps (oldVnode, vnode) { 27615 if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { 27616 return 27617 } 27618 var key, cur; 27619 var elm = vnode.elm; 27620 var oldProps = oldVnode.data.domProps || {}; 27621 var props = vnode.data.domProps || {}; 27622 // clone observed objects, as the user probably wants to mutate it 27623 if (isDef(props.__ob__)) { 27624 props = vnode.data.domProps = extend({}, props); 27625 } 27626 27627 for (key in oldProps) { 27628 if (isUndef(props[key])) { 27629 elm[key] = ''; 27630 } 27631 } 27632 for (key in props) { 27633 cur = props[key]; 27634 // ignore children if the node has textContent or innerHTML, 27635 // as these will throw away existing DOM nodes and cause removal errors 27636 // on subsequent patches (#3360) 27637 if (key === 'textContent' || key === 'innerHTML') { 27638 if (vnode.children) { vnode.children.length = 0; } 27639 if (cur === oldProps[key]) { continue } 27640 // #6601 work around Chrome version <= 55 bug where single textNode 27641 // replaced by innerHTML/textContent retains its parentNode property 27642 if (elm.childNodes.length === 1) { 27643 elm.removeChild(elm.childNodes[0]); 27644 } 27645 } 27646 27647 if (key === 'value') { 27648 // store value as _value as well since 27649 // non-string values will be stringified 27650 elm._value = cur; 27651 // avoid resetting cursor position when value is the same 27652 var strCur = isUndef(cur) ? '' : String(cur); 27653 if (shouldUpdateValue(elm, strCur)) { 27654 elm.value = strCur; 27655 } 27656 } else { 27657 elm[key] = cur; 27658 } 27659 } 27660} 27661 27662// check platforms/web/util/attrs.js acceptValue 27663 27664 27665function shouldUpdateValue (elm, checkVal) { 27666 return (!elm.composing && ( 27667 elm.tagName === 'OPTION' || 27668 isDirty(elm, checkVal) || 27669 isInputChanged(elm, checkVal) 27670 )) 27671} 27672 27673function isDirty (elm, checkVal) { 27674 // return true when textbox (.number and .trim) loses focus and its value is 27675 // not equal to the updated value 27676 var notInFocus = true; 27677 // #6157 27678 // work around IE bug when accessing document.activeElement in an iframe 27679 try { notInFocus = document.activeElement !== elm; } catch (e) {} 27680 return notInFocus && elm.value !== checkVal 27681} 27682 27683function isInputChanged (elm, newVal) { 27684 var value = elm.value; 27685 var modifiers = elm._vModifiers; // injected by v-model runtime 27686 if (isDef(modifiers) && modifiers.number) { 27687 return toNumber(value) !== toNumber(newVal) 27688 } 27689 if (isDef(modifiers) && modifiers.trim) { 27690 return value.trim() !== newVal.trim() 27691 } 27692 return value !== newVal 27693} 27694 27695var domProps = { 27696 create: updateDOMProps, 27697 update: updateDOMProps 27698}; 27699 27700/* */ 27701 27702var parseStyleText = cached(function (cssText) { 27703 var res = {}; 27704 var listDelimiter = /;(?![^(]*\))/g; 27705 var propertyDelimiter = /:(.+)/; 27706 cssText.split(listDelimiter).forEach(function (item) { 27707 if (item) { 27708 var tmp = item.split(propertyDelimiter); 27709 tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); 27710 } 27711 }); 27712 return res 27713}
vendor: 17,089 bytes, lines 27713-28363
27713); 27714 27715// merge static and dynamic style data on the same vnode 27716function normalizeStyleData (data) { 27717 var style = normalizeStyleBinding(data.style); 27718 // static style is pre-processed into an object during compilation 27719 // and is always a fresh object, so it's safe to merge into it 27720 return data.staticStyle 27721 ? extend(data.staticStyle, style) 27722 : style 27723} 27724 27725// normalize possible array / string values into Object 27726function normalizeStyleBinding (bindingStyle) { 27727 if (Array.isArray(bindingStyle)) { 27728 return toObject(bindingStyle) 27729 } 27730 if (typeof bindingStyle === 'string') { 27731 return parseStyleText(bindingStyle) 27732 } 27733 return bindingStyle 27734} 27735 27736/** 27737 * parent component style should be after child's 27738 * so that parent component's style could override it 27739 */ 27740function getStyle (vnode, checkChild) { 27741 var res = {}; 27742 var styleData; 27743 27744 if (checkChild) { 27745 var childNode = vnode; 27746 while (childNode.componentInstance) { 27747 childNode = childNode.componentInstance._vnode; 27748 if (childNode.data && (styleData = normalizeStyleData(childNode.data))) { 27749 extend(res, styleData); 27750 } 27751 } 27752 } 27753 27754 if ((styleData = normalizeStyleData(vnode.data))) { 27755 extend(res, styleData); 27756 } 27757 27758 var parentNode = vnode; 27759 while ((parentNode = parentNode.parent)) { 27760 if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { 27761 extend(res, styleData); 27762 } 27763 } 27764 return res 27765} 27766 27767/* */ 27768 27769var cssVarRE = /^--/; 27770var importantRE = /\s*!important$/; 27771var setProp = function (el, name, val) { 27772 /* istanbul ignore if */ 27773 if (cssVarRE.test(name)) { 27774 el.style.setProperty(name, val); 27775 } else if (importantRE.test(val)) { 27776 el.style.setProperty(name, val.replace(importantRE, ''), 'important'); 27777 } else { 27778 var normalizedName = normalize(name); 27779 if (Array.isArray(val)) { 27780 // Support values array created by autoprefixer, e.g. 27781 // {display: ["-webkit-box", "-ms-flexbox", "flex"]} 27782 // Set them one by one, and the browser will only set those it can recognize 27783 for (var i = 0, len = val.length; i < len; i++) { 27784 el.style[normalizedName] = val[i]; 27785 } 27786 } else { 27787 el.style[normalizedName] = val; 27788 } 27789 } 27790}; 27791 27792var vendorNames = ['Webkit', 'Moz', 'ms']; 27793 27794var emptyStyle; 27795var normalize = cached(function (prop) { 27796 emptyStyle = emptyStyle || document.createElement('div').style; 27797 prop = camelize(prop); 27798 if (prop !== 'filter' && (prop in emptyStyle)) { 27799 return prop 27800 } 27801 var capName = prop.charAt(0).toUpperCase() + prop.slice(1); 27802 for (var i = 0; i < vendorNames.length; i++) { 27803 var name = vendorNames[i] + capName; 27804 if (name in emptyStyle) { 27805 return name 27806 } 27807 } 27808}); 27809 27810function updateStyle (oldVnode, vnode) { 27811 var data = vnode.data; 27812 var oldData = oldVnode.data; 27813 27814 if (isUndef(data.staticStyle) && isUndef(data.style) && 27815 isUndef(oldData.staticStyle) && isUndef(oldData.style) 27816 ) { 27817 return 27818 } 27819 27820 var cur, name; 27821 var el = vnode.elm; 27822 var oldStaticStyle = oldData.staticStyle; 27823 var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; 27824 27825 // if static style exists, stylebinding already merged into it when doing normalizeStyleData 27826 var oldStyle = oldStaticStyle || oldStyleBinding; 27827 27828 var style = normalizeStyleBinding(vnode.data.style) || {}; 27829 27830 // store normalized style under a different key for next diff 27831 // make sure to clone it if it's reactive, since the user likely wants 27832 // to mutate it. 27833 vnode.data.normalizedStyle = isDef(style.__ob__) 27834 ? extend({}, style) 27835 : style; 27836 27837 var newStyle = getStyle(vnode, true); 27838 27839 for (name in oldStyle) { 27840 if (isUndef(newStyle[name])) { 27841 setProp(el, name, ''); 27842 } 27843 } 27844 for (name in newStyle) { 27845 cur = newStyle[name]; 27846 if (cur !== oldStyle[name]) { 27847 // ie9 setting to null has no effect, must use empty string 27848 setProp(el, name, cur == null ? '' : cur); 27849 } 27850 } 27851} 27852 27853var style = { 27854 create: updateStyle, 27855 update: updateStyle 27856}; 27857 27858/* */ 27859 27860/** 27861 * Add class with compatibility for SVG since classList is not supported on 27862 * SVG elements in IE 27863 */ 27864function addClass (el, cls) { 27865 /* istanbul ignore if */ 27866 if (!cls || !(cls = cls.trim())) { 27867 return 27868 } 27869 27870 /* istanbul ignore else */ 27871 if (el.classList) { 27872 if (cls.indexOf(' ') > -1) { 27873 cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); }); 27874 } else { 27875 el.classList.add(cls); 27876 } 27877 } else { 27878 var cur = " " + (el.getAttribute('class') || '') + " "; 27879 if (cur.indexOf(' ' + cls + ' ') < 0) { 27880 el.setAttribute('class', (cur + cls).trim()); 27881 } 27882 } 27883} 27884 27885/** 27886 * Remove class with compatibility for SVG since classList is not supported on 27887 * SVG elements in IE 27888 */ 27889function removeClass (el, cls) { 27890 /* istanbul ignore if */ 27891 if (!cls || !(cls = cls.trim())) { 27892 return 27893 } 27894 27895 /* istanbul ignore else */ 27896 if (el.classList) { 27897 if (cls.indexOf(' ') > -1) { 27898 cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); }); 27899 } else { 27900 el.classList.remove(cls); 27901 } 27902 if (!el.classList.length) { 27903 el.removeAttribute('class'); 27904 } 27905 } else { 27906 var cur = " " + (el.getAttribute('class') || '') + " "; 27907 var tar = ' ' + cls + ' '; 27908 while (cur.indexOf(tar) >= 0) { 27909 cur = cur.replace(tar, ' '); 27910 } 27911 cur = cur.trim(); 27912 if (cur) { 27913 el.setAttribute('class', cur); 27914 } else { 27915 el.removeAttribute('class'); 27916 } 27917 } 27918} 27919 27920/* */ 27921 27922function resolveTransition (def) { 27923 if (!def) { 27924 return 27925 } 27926 /* istanbul ignore else */ 27927 if (typeof def === 'object') { 27928 var res = {}; 27929 if (def.css !== false) { 27930 extend(res, autoCssTransition(def.name || 'v')); 27931 } 27932 extend(res, def); 27933 return res 27934 } else if (typeof def === 'string') { 27935 return autoCssTransition(def) 27936 } 27937} 27938 27939var autoCssTransition = cached(function (name) { 27940 return { 27941 enterClass: (name + "-enter"), 27942 enterToClass: (name + "-enter-to"), 27943 enterActiveClass: (name + "-enter-active"), 27944 leaveClass: (name + "-leave"), 27945 leaveToClass: (name + "-leave-to"), 27946 leaveActiveClass: (name + "-leave-active") 27947 } 27948}); 27949 27950var hasTransition = inBrowser && !isIE9; 27951var TRANSITION = 'transition'; 27952var ANIMATION = 'animation'; 27953 27954// Transition property/event sniffing 27955var transitionProp = 'transition'; 27956var transitionEndEvent = 'transitionend'; 27957var animationProp = 'animation'; 27958var animationEndEvent = 'animationend'; 27959if (hasTransition) { 27960 /* istanbul ignore if */ 27961 if (window.ontransitionend === undefined && 27962 window.onwebkittransitionend !== undefined 27963 ) { 27964 transitionProp = 'WebkitTransition'; 27965 transitionEndEvent = 'webkitTransitionEnd'; 27966 } 27967 if (window.onanimationend === undefined && 27968 window.onwebkitanimationend !== undefined 27969 ) { 27970 animationProp = 'WebkitAnimation'; 27971 animationEndEvent = 'webkitAnimationEnd'; 27972 } 27973} 27974 27975// binding to window is necessary to make hot reload work in IE in strict mode 27976var raf = inBrowser 27977 ? window.requestAnimationFrame 27978 ? window.requestAnimationFrame.bind(window) 27979 : setTimeout 27980 : /* istanbul ignore next */ function (fn) { return fn(); }; 27981 27982function nextFrame (fn) { 27983 raf(function () { 27984 raf(fn); 27985 }); 27986} 27987 27988function addTransitionClass (el, cls) { 27989 var transitionClasses = el._transitionClasses || (el._transitionClasses = []); 27990 if (transitionClasses.indexOf(cls) < 0) { 27991 transitionClasses.push(cls); 27992 addClass(el, cls); 27993 } 27994} 27995 27996function removeTransitionClass (el, cls) { 27997 if (el._transitionClasses) { 27998 remove(el._transitionClasses, cls); 27999 } 28000 removeClass(el, cls); 28001} 28002 28003function whenTransitionEnds ( 28004 el, 28005 expectedType, 28006 cb 28007) { 28008 var ref = getTransitionInfo(el, expectedType); 28009 var type = ref.type; 28010 var timeout = ref.timeout; 28011 var propCount = ref.propCount; 28012 if (!type) { return cb() } 28013 var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; 28014 var ended = 0; 28015 var end = function () { 28016 el.removeEventListener(event, onEnd); 28017 cb(); 28018 }; 28019 var onEnd = function (e) { 28020 if (e.target === el) { 28021 if (++ended >= propCount) { 28022 end(); 28023 } 28024 } 28025 }; 28026 setTimeout(function () { 28027 if (ended < propCount) { 28028 end(); 28029 } 28030 }, timeout + 1); 28031 el.addEventListener(event, onEnd); 28032} 28033 28034var transformRE = /\b(transform|all)(,|$)/; 28035 28036function getTransitionInfo (el, expectedType) { 28037 var styles = window.getComputedStyle(el); 28038 var transitionDelays = styles[transitionProp + 'Delay'].split(', '); 28039 var transitionDurations = styles[transitionProp + 'Duration'].split(', '); 28040 var transitionTimeout = getTimeout(transitionDelays, transitionDurations); 28041 var animationDelays = styles[animationProp + 'Delay'].split(', '); 28042 var animationDurations = styles[animationProp + 'Duration'].split(', '); 28043 var animationTimeout = getTimeout(animationDelays, animationDurations); 28044 28045 var type; 28046 var timeout = 0; 28047 var propCount = 0; 28048 /* istanbul ignore if */ 28049 if (expectedType === TRANSITION) { 28050 if (transitionTimeout > 0) { 28051 type = TRANSITION; 28052 timeout = transitionTimeout; 28053 propCount = transitionDurations.length; 28054 } 28055 } else if (expectedType === ANIMATION) { 28056 if (animationTimeout > 0) { 28057 type = ANIMATION; 28058 timeout = animationTimeout; 28059 propCount = animationDurations.length; 28060 } 28061 } else { 28062 timeout = Math.max(transitionTimeout, animationTimeout); 28063 type = timeout > 0 28064 ? transitionTimeout > animationTimeout 28065 ? TRANSITION 28066 : ANIMATION 28067 : null; 28068 propCount = type 28069 ? type === TRANSITION 28070 ? transitionDurations.length 28071 : animationDurations.length 28072 : 0; 28073 } 28074 var hasTransform = 28075 type === TRANSITION && 28076 transformRE.test(styles[transitionProp + 'Property']); 28077 return { 28078 type: type, 28079 timeout: timeout, 28080 propCount: propCount, 28081 hasTransform: hasTransform 28082 } 28083} 28084 28085function getTimeout (delays, durations) { 28086 /* istanbul ignore next */ 28087 while (delays.length < durations.length) { 28088 delays = delays.concat(delays); 28089 } 28090 28091 return Math.max.apply(null, durations.map(function (d, i) { 28092 return toMs(d) + toMs(delays[i]) 28093 })) 28094} 28095 28096function toMs (s) { 28097 return Number(s.slice(0, -1)) * 1000 28098} 28099 28100/* */ 28101 28102function enter (vnode, toggleDisplay) { 28103 var el = vnode.elm; 28104 28105 // call leave callback now 28106 if (isDef(el._leaveCb)) { 28107 el._leaveCb.cancelled = true; 28108 el._leaveCb(); 28109 } 28110 28111 var data = resolveTransition(vnode.data.transition); 28112 if (isUndef(data)) { 28113 return 28114 } 28115 28116 /* istanbul ignore if */ 28117 if (isDef(el._enterCb) || el.nodeType !== 1) { 28118 return 28119 } 28120 28121 var css = data.css; 28122 var type = data.type; 28123 var enterClass = data.enterClass; 28124 var enterToClass = data.enterToClass; 28125 var enterActiveClass = data.enterActiveClass; 28126 var appearClass = data.appearClass; 28127 var appearToClass = data.appearToClass; 28128 var appearActiveClass = data.appearActiveClass; 28129 var beforeEnter = data.beforeEnter; 28130 var enter = data.enter; 28131 var afterEnter = data.afterEnter; 28132 var enterCancelled = data.enterCancelled; 28133 var beforeAppear = data.beforeAppear; 28134 var appear = data.appear; 28135 var afterAppear = data.afterAppear; 28136 var appearCancelled = data.appearCancelled; 28137 var duration = data.duration; 28138 28139 // activeInstance will always be the <transition> component managing this 28140 // transition. One edge case to check is when the <transition> is placed 28141 // as the root node of a child component. In that case we need to check 28142 // <transition>'s parent for appear check. 28143 var context = activeInstance; 28144 var transitionNode = activeInstance.$vnode; 28145 while (transitionNode && transitionNode.parent) { 28146 transitionNode = transitionNode.parent; 28147 context = transitionNode.context; 28148 } 28149 28150 var isAppear = !context._isMounted || !vnode.isRootInsert; 28151 28152 if (isAppear && !appear && appear !== '') { 28153 return 28154 } 28155 28156 var startClass = isAppear && appearClass 28157 ? appearClass 28158 : enterClass; 28159 var activeClass = isAppear && appearActiveClass 28160 ? appearActiveClass 28161 : enterActiveClass; 28162 var toClass = isAppear && appearToClass 28163 ? appearToClass 28164 : enterToClass; 28165 28166 var beforeEnterHook = isAppear 28167 ? (beforeAppear || beforeEnter) 28168 : beforeEnter; 28169 var enterHook = isAppear 28170 ? (typeof appear === 'function' ? appear : enter) 28171 : enter; 28172 var afterEnterHook = isAppear 28173 ? (afterAppear || afterEnter) 28174 : afterEnter; 28175 var enterCancelledHook = isAppear 28176 ? (appearCancelled || enterCancelled) 28177 : enterCancelled; 28178 28179 var explicitEnterDuration = toNumber( 28180 isObject(duration) 28181 ? duration.enter 28182 : duration 28183 ); 28184 28185 if ("development" !== 'production' && explicitEnterDuration != null) { 28186 checkDuration(explicitEnterDuration, 'enter', vnode); 28187 } 28188 28189 var expectsCSS = css !== false && !isIE9; 28190 var userWantsControl = getHookArgumentsLength(enterHook); 28191 28192 var cb = el._enterCb = once(function () { 28193 if (expectsCSS) { 28194 removeTransitionClass(el, toClass); 28195 removeTransitionClass(el, activeClass); 28196 } 28197 if (cb.cancelled) { 28198 if (expectsCSS) { 28199 removeTransitionClass(el, startClass); 28200 } 28201 enterCancelledHook && enterCancelledHook(el); 28202 } else { 28203 afterEnterHook && afterEnterHook(el); 28204 } 28205 el._enterCb = null; 28206 }); 28207 28208 if (!vnode.data.show) { 28209 // remove pending leave element on enter by injecting an insert hook 28210 mergeVNodeHook(vnode, 'insert', function () { 28211 var parent = el.parentNode; 28212 var pendingNode = parent && parent._pending && parent._pending[vnode.key]; 28213 if (pendingNode && 28214 pendingNode.tag === vnode.tag && 28215 pendingNode.elm._leaveCb 28216 ) { 28217 pendingNode.elm._leaveCb(); 28218 } 28219 enterHook && enterHook(el, cb); 28220 }); 28221 } 28222 28223 // start enter transition 28224 beforeEnterHook && beforeEnterHook(el); 28225 if (expectsCSS) { 28226 addTransitionClass(el, startClass); 28227 addTransitionClass(el, activeClass); 28228 nextFrame(function () { 28229 addTransitionClass(el, toClass); 28230 removeTransitionClass(el, startClass); 28231 if (!cb.cancelled && !userWantsControl) { 28232 if (isValidDuration(explicitEnterDuration)) { 28233 setTimeout(cb, explicitEnterDuration); 28234 } else { 28235 whenTransitionEnds(el, type, cb); 28236 } 28237 } 28238 }); 28239 } 28240 28241 if (vnode.data.show) { 28242 toggleDisplay && toggleDisplay(); 28243 enterHook && enterHook(el, cb); 28244 } 28245 28246 if (!expectsCSS && !userWantsControl) { 28247 cb(); 28248 } 28249} 28250 28251function leave (vnode, rm) { 28252 var el = vnode.elm; 28253 28254 // call enter callback now 28255 if (isDef(el._enterCb)) { 28256 el._enterCb.cancelled = true; 28257 el._enterCb(); 28258 } 28259 28260 var data = resolveTransition(vnode.data.transition); 28261 if (isUndef(data) || el.nodeType !== 1) { 28262 return rm() 28263 } 28264 28265 /* istanbul ignore if */ 28266 if (isDef(el._leaveCb)) { 28267 return 28268 } 28269 28270 var css = data.css; 28271 var type = data.type; 28272 var leaveClass = data.leaveClass; 28273 var leaveToClass = data.leaveToClass; 28274 var leaveActiveClass = data.leaveActiveClass; 28275 var beforeLeave = data.beforeLeave; 28276 var leave = data.leave; 28277 var afterLeave = data.afterLeave; 28278 var leaveCancelled = data.leaveCancelled; 28279 var delayLeave = data.delayLeave; 28280 var duration = data.duration; 28281 28282 var expectsCSS = css !== false && !isIE9; 28283 var userWantsControl = getHookArgumentsLength(leave); 28284 28285 var explicitLeaveDuration = toNumber( 28286 isObject(duration) 28287 ? duration.leave 28288 : duration 28289 ); 28290 28291 if ("development" !== 'production' && isDef(explicitLeaveDuration)) { 28292 checkDuration(explicitLeaveDuration, 'leave', vnode); 28293 } 28294 28295 var cb = el._leaveCb = once(function () { 28296 if (el.parentNode && el.parentNode._pending) { 28297 el.parentNode._pending[vnode.key] = null; 28298 } 28299 if (expectsCSS) { 28300 removeTransitionClass(el, leaveToClass); 28301 removeTransitionClass(el, leaveActiveClass); 28302 } 28303 if (cb.cancelled) { 28304 if (expectsCSS) { 28305 removeTransitionClass(el, leaveClass); 28306 } 28307 leaveCancelled && leaveCancelled(el); 28308 } else { 28309 rm(); 28310 afterLeave && afterLeave(el); 28311 } 28312 el._leaveCb = null; 28313 }); 28314 28315 if (delayLeave) { 28316 delayLeave(performLeave); 28317 } else { 28318 performLeave(); 28319 } 28320 28321 function performLeave () { 28322 // the delayed leave may have already been cancelled 28323 if (cb.cancelled) { 28324 return 28325 } 28326 // record leaving element 28327 if (!vnode.data.show) { 28328 (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode; 28329 } 28330 beforeLeave && beforeLeave(el); 28331 if (expectsCSS) { 28332 addTransitionClass(el, leaveClass); 28333 addTransitionClass(el, leaveActiveClass); 28334 nextFrame(function () { 28335 addTransitionClass(el, leaveToClass); 28336 removeTransitionClass(el, leaveClass); 28337 if (!cb.cancelled && !userWantsControl) { 28338 if (isValidDuration(explicitLeaveDuration)) { 28339 setTimeout(cb, explicitLeaveDuration); 28340 } else { 28341 whenTransitionEnds(el, type, cb); 28342 } 28343 } 28344 }); 28345 } 28346 leave && leave(el, cb); 28347 if (!expectsCSS && !userWantsControl) { 28348 cb(); 28349 } 28350 } 28351} 28352 28353// only used in dev mode 28354function checkDuration (val, name, vnode) { 28355 if (typeof val !== 'number') { 28356 warn( 28357 "<transition> explicit " + name + " duration is not a valid number - " + 28358 "got " + (JSON.stringify(val)) + ".", 28359 vnode.context 28360 ); 28361 } else if (isNaN(val)) { 28362 warn( 28363 "<transition>
vendor: 5,572 bytes, lines 28363-28564
28363 explicit " + name + " duration is NaN - " + 28364 'the duration expression might be incorrect.', 28365 vnode.context 28366 ); 28367 } 28368} 28369 28370function isValidDuration (val) { 28371 return typeof val === 'number' && !isNaN(val) 28372} 28373 28374/** 28375 * Normalize a transition hook's argument length. The hook may be: 28376 * - a merged hook (invoker) with the original in .fns 28377 * - a wrapped component method (check ._length) 28378 * - a plain function (.length) 28379 */ 28380function getHookArgumentsLength (fn) { 28381 if (isUndef(fn)) { 28382 return false 28383 } 28384 var invokerFns = fn.fns; 28385 if (isDef(invokerFns)) { 28386 // invoker 28387 return getHookArgumentsLength( 28388 Array.isArray(invokerFns) 28389 ? invokerFns[0] 28390 : invokerFns 28391 ) 28392 } else { 28393 return (fn._length || fn.length) > 1 28394 } 28395} 28396 28397function _enter (_, vnode) { 28398 if (vnode.data.show !== true) { 28399 enter(vnode); 28400 } 28401} 28402 28403var transition = inBrowser ? { 28404 create: _enter, 28405 activate: _enter, 28406 remove: function remove$$1 (vnode, rm) { 28407 /* istanbul ignore else */ 28408 if (vnode.data.show !== true) { 28409 leave(vnode, rm); 28410 } else { 28411 rm(); 28412 } 28413 } 28414} : {}; 28415 28416var platformModules = [ 28417 attrs, 28418 klass, 28419 events, 28420 domProps, 28421 style, 28422 transition 28423]; 28424 28425/* */ 28426 28427// the directive module should be applied last, after all 28428// built-in modules have been applied. 28429var modules = platformModules.concat(baseModules); 28430 28431var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules }); 28432 28433/** 28434 * Not type checking this file because flow doesn't like attaching 28435 * properties to Elements. 28436 */ 28437 28438/* istanbul ignore if */ 28439if (isIE9) { 28440 // http://www.matts411.com/post/internet-explorer-9-oninput/ 28441 document.addEventListener('selectionchange', function () { 28442 var el = document.activeElement; 28443 if (el && el.vmodel) { 28444 trigger(el, 'input'); 28445 } 28446 }); 28447} 28448 28449var directive = { 28450 inserted: function inserted (el, binding, vnode, oldVnode) { 28451 if (vnode.tag === 'select') { 28452 // #6903 28453 if (oldVnode.elm && !oldVnode.elm._vOptions) { 28454 mergeVNodeHook(vnode, 'postpatch', function () { 28455 directive.componentUpdated(el, binding, vnode); 28456 }); 28457 } else { 28458 setSelected(el, binding, vnode.context); 28459 } 28460 el._vOptions = [].map.call(el.options, getValue); 28461 } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) { 28462 el._vModifiers = binding.modifiers; 28463 if (!binding.modifiers.lazy) { 28464 // Safari < 10.2 & UIWebView doesn't fire compositionend when 28465 // switching focus before confirming composition choice 28466 // this also fixes the issue where some browsers e.g. iOS Chrome 28467 // fires "change" instead of "input" on autocomplete. 28468 el.addEventListener('change', onCompositionEnd); 28469 if (!isAndroid) { 28470 el.addEventListener('compositionstart', onCompositionStart); 28471 el.addEventListener('compositionend', onCompositionEnd); 28472 } 28473 /* istanbul ignore if */ 28474 if (isIE9) { 28475 el.vmodel = true; 28476 } 28477 } 28478 } 28479 }, 28480 28481 componentUpdated: function componentUpdated (el, binding, vnode) { 28482 if (vnode.tag === 'select') { 28483 setSelected(el, binding, vnode.context); 28484 // in case the options rendered by v-for have changed, 28485 // it's possible that the value is out-of-sync with the rendered options. 28486 // detect such cases and filter out values that no longer has a matching 28487 // option in the DOM. 28488 var prevOptions = el._vOptions; 28489 var curOptions = el._vOptions = [].map.call(el.options, getValue); 28490 if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) { 28491 // trigger change event if 28492 // no matching option found for at least one value 28493 var needReset = el.multiple 28494 ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); }) 28495 : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions); 28496 if (needReset) { 28497 trigger(el, 'change'); 28498 } 28499 } 28500 } 28501 } 28502}; 28503 28504function setSelected (el, binding, vm) { 28505 actuallySetSelected(el, binding, vm); 28506 /* istanbul ignore if */ 28507 if (isIE || isEdge) { 28508 setTimeout(function () { 28509 actuallySetSelected(el, binding, vm); 28510 }, 0); 28511 } 28512} 28513 28514function actuallySetSelected (el, binding, vm) { 28515 var value = binding.value; 28516 var isMultiple = el.multiple; 28517 if (isMultiple && !Array.isArray(value)) { 28518 "development" !== 'production' && warn( 28519 "<select multiple v-model=\"" + (binding.expression) + "\"> " + 28520 "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)), 28521 vm 28522 ); 28523 return 28524 } 28525 var selected, option; 28526 for (var i = 0, l = el.options.length; i < l; i++) { 28527 option = el.options[i]; 28528 if (isMultiple) { 28529 selected = looseIndexOf(value, getValue(option)) > -1; 28530 if (option.selected !== selected) { 28531 option.selected = selected; 28532 } 28533 } else { 28534 if (looseEqual(getValue(option), value)) { 28535 if (el.selectedIndex !== i) { 28536 el.selectedIndex = i; 28537 } 28538 return 28539 } 28540 } 28541 } 28542 if (!isMultiple) { 28543 el.selectedIndex = -1; 28544 } 28545} 28546 28547function hasNoMatchingOption (value, options) { 28548 return options.every(function (o) { return !looseEqual(o, value); }) 28549} 28550 28551function getValue (option) { 28552 return '_value' in option 28553 ? option._value 28554 : option.value 28555} 28556 28557function onCompositionStart (e) { 28558 e.target.composing = true; 28559} 28560 28561function onCompositionEnd (e) { 28562 // prevent triggering an input event for no reason 28563 if (!e.target.composing) { return } 28564 e.target.composing = false;
vendor: 4,308 bytes, lines 28565-28745
28565 trigger(e.target, 'input'); 28566} 28567 28568function trigger (el, type) { 28569 var e = document.createEvent('HTMLEvents'); 28570 e.initEvent(type, true, true); 28571 el.dispatchEvent(e); 28572} 28573 28574/* */ 28575 28576// recursively search for possible transition defined inside the component root 28577function locateNode (vnode) { 28578 return vnode.componentInstance && (!vnode.data || !vnode.data.transition) 28579 ? locateNode(vnode.componentInstance._vnode) 28580 : vnode 28581} 28582 28583var show = { 28584 bind: function bind (el, ref, vnode) { 28585 var value = ref.value; 28586 28587 vnode = locateNode(vnode); 28588 var transition$$1 = vnode.data && vnode.data.transition; 28589 var originalDisplay = el.__vOriginalDisplay = 28590 el.style.display === 'none' ? '' : el.style.display; 28591 if (value && transition$$1) { 28592 vnode.data.show = true; 28593 enter(vnode, function () { 28594 el.style.display = originalDisplay; 28595 }); 28596 } else { 28597 el.style.display = value ? originalDisplay : 'none'; 28598 } 28599 }, 28600 28601 update: function update (el, ref, vnode) { 28602 var value = ref.value; 28603 var oldValue = ref.oldValue; 28604 28605 /* istanbul ignore if */ 28606 if (value === oldValue) { return } 28607 vnode = locateNode(vnode); 28608 var transition$$1 = vnode.data && vnode.data.transition; 28609 if (transition$$1) { 28610 vnode.data.show = true; 28611 if (value) { 28612 enter(vnode, function () { 28613 el.style.display = el.__vOriginalDisplay; 28614 }); 28615 } else { 28616 leave(vnode, function () { 28617 el.style.display = 'none'; 28618 }); 28619 } 28620 } else { 28621 el.style.display = value ? el.__vOriginalDisplay : 'none'; 28622 } 28623 }, 28624 28625 unbind: function unbind ( 28626 el, 28627 binding, 28628 vnode, 28629 oldVnode, 28630 isDestroy 28631 ) { 28632 if (!isDestroy) { 28633 el.style.display = el.__vOriginalDisplay; 28634 } 28635 } 28636}; 28637 28638var platformDirectives = { 28639 model: directive, 28640 show: show 28641}; 28642 28643/* */ 28644 28645// Provides transition support for a single element/component. 28646// supports transition mode (out-in / in-out) 28647 28648var transitionProps = { 28649 name: String, 28650 appear: Boolean, 28651 css: Boolean, 28652 mode: String, 28653 type: String, 28654 enterClass: String, 28655 leaveClass: String, 28656 enterToClass: String, 28657 leaveToClass: String, 28658 enterActiveClass: String, 28659 leaveActiveClass: String, 28660 appearClass: String, 28661 appearActiveClass: String, 28662 appearToClass: String, 28663 duration: [Number, String, Object] 28664}; 28665 28666// in case the child is also an abstract component, e.g. <keep-alive> 28667// we want to recursively retrieve the real component to be rendered 28668function getRealChild (vnode) { 28669 var compOptions = vnode && vnode.componentOptions; 28670 if (compOptions && compOptions.Ctor.options.abstract) { 28671 return getRealChild(getFirstComponentChild(compOptions.children)) 28672 } else { 28673 return vnode 28674 } 28675} 28676 28677function extractTransitionData (comp) { 28678 var data = {}; 28679 var options = comp.$options; 28680 // props 28681 for (var key in options.propsData) { 28682 data[key] = comp[key]; 28683 } 28684 // events. 28685 // extract listeners and pass them directly to the transition methods 28686 var listeners = options._parentListeners; 28687 for (var key$1 in listeners) { 28688 data[camelize(key$1)] = listeners[key$1]; 28689 } 28690 return data 28691} 28692 28693function placeholder (h, rawChild) { 28694 if (/\d-keep-alive$/.test(rawChild.tag)) { 28695 return h('keep-alive', { 28696 props: rawChild.componentOptions.propsData 28697 }) 28698 } 28699} 28700 28701function hasParentTransition (vnode) { 28702 while ((vnode = vnode.parent)) { 28703 if (vnode.data.transition) { 28704 return true 28705 } 28706 } 28707} 28708 28709function isSameChild (child, oldChild) { 28710 return oldChild.key === child.key && oldChild.tag === child.tag 28711} 28712 28713var Transition = { 28714 name: 'transition', 28715 props: transitionProps, 28716 abstract: true, 28717 28718 render: function render (h) { 28719 var this$1 = this; 28720 28721 var children = this.$slots.default; 28722 if (!children) { 28723 return 28724 } 28725 28726 // filter out text nodes (possible whitespaces) 28727 children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c); }); 28728 /* istanbul ignore if */ 28729 if (!children.length) { 28730 return 28731 } 28732 28733 // warn multiple elements 28734 if ("development" !== 'production' && children.length > 1) { 28735 warn( 28736 '<transition> can only be used on a single element. Use ' + 28737 '<transition-group> for lists.', 28738 this.$parent 28739 ); 28740 } 28741 28742 var mode = this.mode; 28743 28744 // warn invalid mode 28745 if ("development" !== 'production' &&
vendor: 4,142 bytes, lines 28746-28870
28746 mode && mode !== 'in-out' && mode !== 'out-in' 28747 ) { 28748 warn( 28749 'invalid <transition> mode: ' + mode, 28750 this.$parent 28751 ); 28752 } 28753 28754 var rawChild = children[0]; 28755 28756 // if this is a component root node and the component's 28757 // parent container node also has transition, skip. 28758 if (hasParentTransition(this.$vnode)) { 28759 return rawChild 28760 } 28761 28762 // apply transition data to child 28763 // use getRealChild() to ignore abstract components e.g. keep-alive 28764 var child = getRealChild(rawChild); 28765 /* istanbul ignore if */ 28766 if (!child) { 28767 return rawChild 28768 } 28769 28770 if (this._leaving) { 28771 return placeholder(h, rawChild) 28772 } 28773 28774 // ensure a key that is unique to the vnode type and to this transition 28775 // component instance. This key will be used to remove pending leaving nodes 28776 // during entering. 28777 var id = "__transition-" + (this._uid) + "-"; 28778 child.key = child.key == null 28779 ? child.isComment 28780 ? id + 'comment' 28781 : id + child.tag 28782 : isPrimitive(child.key) 28783 ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key) 28784 : child.key; 28785 28786 var data = (child.data || (child.data = {})).transition = extractTransitionData(this); 28787 var oldRawChild = this._vnode; 28788 var oldChild = getRealChild(oldRawChild); 28789 28790 // mark v-show 28791 // so that the transition module can hand over the control to the directive 28792 if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) { 28793 child.data.show = true; 28794 } 28795 28796 if ( 28797 oldChild && 28798 oldChild.data && 28799 !isSameChild(child, oldChild) && 28800 !isAsyncPlaceholder(oldChild) && 28801 // #6687 component root is a comment node 28802 !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment) 28803 ) { 28804 // replace old child transition data with fresh one 28805 // important for dynamic transitions! 28806 var oldData = oldChild.data.transition = extend({}, data); 28807 // handle transition mode 28808 if (mode === 'out-in') { 28809 // return placeholder node and queue update when leave finishes 28810 this._leaving = true; 28811 mergeVNodeHook(oldData, 'afterLeave', function () { 28812 this$1._leaving = false; 28813 this$1.$forceUpdate(); 28814 }); 28815 return placeholder(h, rawChild) 28816 } else if (mode === 'in-out') { 28817 if (isAsyncPlaceholder(child)) { 28818 return oldRawChild 28819 } 28820 var delayedLeave; 28821 var performLeave = function () { delayedLeave(); }; 28822 mergeVNodeHook(data, 'afterEnter', performLeave); 28823 mergeVNodeHook(data, 'enterCancelled', performLeave); 28824 mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; }); 28825 } 28826 } 28827 28828 return rawChild 28829 } 28830}; 28831 28832/* */ 28833 28834// Provides transition support for list items. 28835// supports move transitions using the FLIP technique. 28836 28837// Because the vdom's children update algorithm is "unstable" - i.e. 28838// it doesn't guarantee the relative positioning of removed elements, 28839// we force transition-group to update its children into two passes: 28840// in the first pass, we remove all nodes that need to be removed, 28841// triggering their leaving transition; in the second pass, we insert/move 28842// into the final desired state. This way in the second pass removed 28843// nodes will remain where they should be. 28844 28845var props = extend({ 28846 tag: String, 28847 moveClass: String 28848}, transitionProps); 28849 28850delete props.mode; 28851 28852var TransitionGroup = { 28853 props: props, 28854 28855 render: function render (h) { 28856 var tag = this.tag || this.$vnode.data.tag || 'span'; 28857 var map = Object.create(null); 28858 var prevChildren = this.prevChildren = this.children; 28859 var rawChildren = this.$slots.default || []; 28860 var children = this.children = []; 28861 var transitionData = extractTransitionData(this); 28862 28863 for (var i = 0; i < rawChildren.length; i++) { 28864 var c = rawChildren[i]; 28865 if (c.tag) { 28866 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { 28867 children.push(c); 28868 map[c.key] = c 28869 ;(c.data || (c.data = {})).transition = transitionData; 28870 } else {
vendor: 5,388 bytes, lines 28871-29054
28871 var opts = c.componentOptions; 28872 var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag; 28873 warn(("<transition-group> children must be keyed: <" + name + ">")); 28874 } 28875 } 28876 } 28877 28878 if (prevChildren) { 28879 var kept = []; 28880 var removed = []; 28881 for (var i$1 = 0; i$1 < prevChildren.length; i$1++) { 28882 var c$1 = prevChildren[i$1]; 28883 c$1.data.transition = transitionData; 28884 c$1.data.pos = c$1.elm.getBoundingClientRect(); 28885 if (map[c$1.key]) { 28886 kept.push(c$1); 28887 } else { 28888 removed.push(c$1); 28889 } 28890 } 28891 this.kept = h(tag, null, kept); 28892 this.removed = removed; 28893 } 28894 28895 return h(tag, null, children) 28896 }, 28897 28898 beforeUpdate: function beforeUpdate () { 28899 // force removing pass 28900 this.__patch__( 28901 this._vnode, 28902 this.kept, 28903 false, // hydrating 28904 true // removeOnly (!important, avoids unnecessary moves) 28905 ); 28906 this._vnode = this.kept; 28907 }, 28908 28909 updated: function updated () { 28910 var children = this.prevChildren; 28911 var moveClass = this.moveClass || ((this.name || 'v') + '-move'); 28912 if (!children.length || !this.hasMove(children[0].elm, moveClass)) { 28913 return 28914 } 28915 28916 // we divide the work into three loops to avoid mixing DOM reads and writes 28917 // in each iteration - which helps prevent layout thrashing. 28918 children.forEach(callPendingCbs); 28919 children.forEach(recordPosition); 28920 children.forEach(applyTranslation); 28921 28922 // force reflow to put everything in position 28923 // assign to this to avoid being removed in tree-shaking 28924 // $flow-disable-line 28925 this._reflow = document.body.offsetHeight; 28926 28927 children.forEach(function (c) { 28928 if (c.data.moved) { 28929 var el = c.elm; 28930 var s = el.style; 28931 addTransitionClass(el, moveClass); 28932 s.transform = s.WebkitTransform = s.transitionDuration = ''; 28933 el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { 28934 if (!e || /transform$/.test(e.propertyName)) { 28935 el.removeEventListener(transitionEndEvent, cb); 28936 el._moveCb = null; 28937 removeTransitionClass(el, moveClass); 28938 } 28939 }); 28940 } 28941 }); 28942 }, 28943 28944 methods: { 28945 hasMove: function hasMove (el, moveClass) { 28946 /* istanbul ignore if */ 28947 if (!hasTransition) { 28948 return false 28949 } 28950 /* istanbul ignore if */ 28951 if (this._hasMove) { 28952 return this._hasMove 28953 } 28954 // Detect whether an element with the move class applied has 28955 // CSS transitions. Since the element may be inside an entering 28956 // transition at this very moment, we make a clone of it and remove 28957 // all other transition classes applied to ensure only the move class 28958 // is applied. 28959 var clone = el.cloneNode(); 28960 if (el._transitionClasses) { 28961 el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); }); 28962 } 28963 addClass(clone, moveClass); 28964 clone.style.display = 'none'; 28965 this.$el.appendChild(clone); 28966 var info = getTransitionInfo(clone); 28967 this.$el.removeChild(clone); 28968 return (this._hasMove = info.hasTransform) 28969 } 28970 } 28971}; 28972 28973function callPendingCbs (c) { 28974 /* istanbul ignore if */ 28975 if (c.elm._moveCb) { 28976 c.elm._moveCb(); 28977 } 28978 /* istanbul ignore if */ 28979 if (c.elm._enterCb) { 28980 c.elm._enterCb(); 28981 } 28982} 28983 28984function recordPosition (c) { 28985 c.data.newPos = c.elm.getBoundingClientRect(); 28986} 28987 28988function applyTranslation (c) { 28989 var oldPos = c.data.pos; 28990 var newPos = c.data.newPos; 28991 var dx = oldPos.left - newPos.left; 28992 var dy = oldPos.top - newPos.top; 28993 if (dx || dy) { 28994 c.data.moved = true; 28995 var s = c.elm.style; 28996 s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)"; 28997 s.transitionDuration = '0s'; 28998 } 28999} 29000 29001var platformComponents = { 29002 Transition: Transition, 29003 TransitionGroup: TransitionGroup 29004}; 29005 29006/* */ 29007 29008// install platform specific utils 29009Vue$3.config.mustUseProp = mustUseProp; 29010Vue$3.config.isReservedTag = isReservedTag; 29011Vue$3.config.isReservedAttr = isReservedAttr; 29012Vue$3.config.getTagNamespace = getTagNamespace; 29013Vue$3.config.isUnknownElement = isUnknownElement; 29014 29015// install platform runtime directives & components 29016extend(Vue$3.options.directives, platformDirectives); 29017extend(Vue$3.options.components, platformComponents); 29018 29019// install platform patch function 29020Vue$3.prototype.__patch__ = inBrowser ? patch : noop; 29021 29022// public mount method 29023Vue$3.prototype.$mount = function ( 29024 el, 29025 hydrating 29026) { 29027 el = el && inBrowser ? query(el) : undefined; 29028 return mountComponent(this, el, hydrating) 29029}; 29030 29031// devtools global hook 29032/* istanbul ignore next */ 29033Vue$3.nextTick(function () { 29034 if (config.devtools) { 29035 if (devtools) { 29036 devtools.emit('init', Vue$3); 29037 } else if ("development" !== 'production' && isChrome) { 29038 console[console.info ? 'info' : 'log']( 29039 'Download the Vue Devtools extension for a better development experience:\n' + 29040 'https://github.com/vuejs/vue-devtools' 29041 ); 29042 } 29043 } 29044 if ("development" !== 'production' && 29045 config.productionTip !== false && 29046 inBrowser && typeof console !== 'undefined' 29047 ) { 29048 console[console.info ? 'info' : 'log']( 29049 "You are running Vue in development mode.\n" + 29050 "Make sure to turn on production mode when deploying for production.\n" + 29051 "See more tips at https://vuejs.org/guide/deployment.html" 29052 ); 29053 } 29054}
29054, 0); 29055 29056/* */ 29057 29058var defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g; 29059var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; 29060 29061var buildRegex = cached(function (delimiters) { 29062 var open = delimiters[0].replace(regexEscapeRE, '\\$&'); 29063 var close = delimiters[1].replace(regexEscapeRE, '\\$&'); 29064 return new RegExp(open + '((?:.|\\n)+?)' + close, 'g') 29065}); 29066 29067function parseText ( 29068 text, 29069 delimiters 29070) { 29071 var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; 29072 if (!tagRE.test(text)) { 29073 return 29074 } 29075 var tokens = []; 29076 var lastIndex = tagRE.lastIndex = 0; 29077 var match, index; 29078 while ((match = tagRE.exec(text))) { 29079 index = match.index; 29080 // push text token 29081 if (index > lastIndex) { 29082 tokens.push(JSON.stringify(text.slice(lastIndex, index))); 29083 } 29084 // tag token 29085 var exp = parseFilters(match[1].trim()); 29086 tokens.push(("_s(" + exp + ")")); 29087 lastIndex = index + match[0].length; 29088 } 29089 if (lastIndex < text.length) { 29090 tokens.push(JSON.stringify(text.slice(lastIndex))); 29091 } 29092 return tokens.join('+') 29093} 29094 29095/* */ 29096 29097function transformNode (el, options) { 29098 var warn = options.warn || baseWarn; 29099 var staticClass = getAndRemoveAttr(el, 'class'); 29100 if ("development" !== 'production' && staticClass) { 29101 var expression = parseText(staticClass, options.delimiters); 29102 if (expression) { 29103 warn( 29104 "class=\"" + staticClass + "\": " + 29105 'Interpolation inside attributes has been removed. ' + 29106 'Use v-bind or the colon shorthand instead. For example, ' + 29107 'instead of <div class="{{ val }}">, use <div :class="val">.' 29108 ); 29109 } 29110 } 29111 if (staticClass) { 29112 el.staticClass = JSON.stringify(staticClass); 29113 } 29114 var classBinding = getBindingAttr(el, 'class', false /* getStatic */); 29115 if (classBinding) { 29116 el.classBinding = classBinding; 29117 } 29118} 29119 29120function genData (el) { 29121 var data = ''; 29122 if (el.staticClass) { 29123 data += "staticClass:" + (el.staticClass) + ","; 29124 } 29125 if (el.classBinding) { 29126 data += "class:" + (el.classBinding) + ","; 29127 } 29128 return data 29129} 29130 29131var klass$1 = { 29132 staticKeys: ['staticClass'], 29133 transformNode: transformNode, 29134 genData: genData 29135}; 29136 29137/* */ 29138 29139function transformNode$1 (el, options) { 29140 var warn = options.warn || baseWarn; 29141 var staticStyle = getAndRemoveAttr(el, 'style'); 29142 if (staticStyle) { 29143 /* istanbul ignore if */ 29144 { 29145 var expression = parseText(staticStyle, options.delimiters); 29146 if (expression) { 29147 warn( 29148 "style=\"" + staticStyle + "\": " + 29149 'Interpolation inside attributes has been removed. ' + 29150 'Use v-bind or the colon shorthand instead. For example, ' + 29151 'instead of <div style="{{ val }}">, use <div :style="val">.' 29152 ); 29153 } 29154 } 29155 el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); 29156 } 29157 29158 var styleBinding = getBindingAttr(el, 'style', false /* getStatic */); 29159 if (styleBinding) { 29160 el.styleBinding = styleBinding; 29161 } 29162} 29163 29164function genData$1 (el) { 29165 var data = ''; 29166 if (el.staticStyle) { 29167 data += "staticStyle:" + (el.staticStyle) + ","; 29168 } 29169 if (el.styleBinding) { 29170 data += "style:(" + (el.styleBinding) + "),"; 29171 } 29172 return data 29173} 29174 29175var style$1 = { 29176 staticKeys: ['staticStyle'], 29177 transformNode: transformNode$1, 29178 genData: genData$1 29179}; 29180 29181/* */ 29182 29183var decoder; 29184 29185var he = { 29186 decode: function decode (html) { 29187 decoder = decoder || document.createElement('div'); 29188 decoder.innerHTML = html; 29189 return decoder.textContent 29190 } 29191}; 29192 29193/* */ 29194 29195var isUnaryTag = makeMap( 29196 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 29197 'link,meta,param,source,track,wbr' 29198); 29199 29200// Elements that you can, intentionally, leave open 29201// (and which close themselves) 29202var canBeLeftOpenTag = makeMap( 29203 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source' 29204); 29205 29206// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 29207// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content 29208var isNonPhrasingTag = makeMap( 29209 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 29210 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 29211 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 29212 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 29213 'title,tr,track' 29214); 29215 29216/** 29217 * Not type-checking this file because it's mostly vendor code. 29218 */ 29219 29220/*! 29221 * HTML Parser By John Resig (ejohn.org) 29222 * Modified by Juriy "kangax" Zaytsev
29223 * Original code by Erik Arvidsson, Mozilla Public License 29224 * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js 29225 */ 29226 29227// Regular Expressions for parsing tags and attributes 29228var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 29229// could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName 29230// but for Vue templates we can enforce a simple charset 29231var ncname = '[a-zA-Z_][\\w\\-\\.]*'; 29232var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")"; 29233var startTagOpen = new RegExp(("^<" + qnameCapture)); 29234var startTagClose = /^\s*(\/?)>/; 29235var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>")); 29236var doctype = /^<!DOCTYPE [^>]+>/i; 29237var comment = /^<!--/; 29238var conditionalComment = /^<!\[/; 29239 29240var IS_REGEX_CAPTURING_BROKEN = false; 29241'x'.replace(/x(.)?/g, function (m, g) { 29242 IS_REGEX_CAPTURING_BROKEN = g === ''; 29243}); 29244 29245// Special Elements (can contain anything) 29246var isPlainTextElement = makeMap('script,style,textarea', true); 29247var reCache = {}; 29248 29249var decodingMap = { 29250 '<': '<', 29251 '>': '>', 29252 '"': '"', 29253 '&': '&', 29254 ' ': '\n', 29255 '	': '\t' 29256}; 29257var encodedAttr = /&(?:lt|gt|quot|amp);/g; 29258var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g; 29259 29260// #5992 29261var isIgnoreNewlineTag = makeMap('pre,textarea', true); 29262var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; }; 29263 29264function decodeAttr (value, shouldDecodeNewlines) { 29265 var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; 29266 return value.replace(re, function (match) { return decodingMap[match]; }) 29267} 29268 29269function parseHTML (html, options) { 29270 var stack = []; 29271 var expectHTML = options.expectHTML; 29272 var isUnaryTag$$1 = options.isUnaryTag || no; 29273 var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; 29274 var index = 0; 29275 var last, lastTag; 29276 while (html) { 29277 last = html; 29278 // Make sure we're not in a plaintext content element like script/style 29279 if (!lastTag || !isPlainTextElement(lastTag)) { 29280 var textEnd = html.indexOf('<'); 29281 if (textEnd === 0) { 29282 // Comment: 29283 if (comment.test(html)) { 29284 var commentEnd = html.indexOf('-->'); 29285 29286 if (commentEnd >= 0) { 29287 if (options.shouldKeepComment) { 29288 options.comment(html.substring(4, commentEnd)); 29289 } 29290 advance(commentEnd + 3); 29291 continue 29292 } 29293 } 29294 29295 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment 29296 if (conditionalComment.test(html)) { 29297 var conditionalEnd = html.indexOf(']>'); 29298 29299 if (conditionalEnd >= 0) { 29300 advance(conditionalEnd + 2); 29301 continue 29302 } 29303 } 29304 29305 // Doctype: 29306 var doctypeMatch = html.match(doctype); 29307 if (doctypeMatch) { 29308 advance(doctypeMatch[0].length); 29309 continue 29310 } 29311 29312 // End tag: 29313 var endTagMatch = html.match(endTag); 29314 if (endTagMatch) { 29315 var curIndex = index; 29316 advance(endTagMatch[0].length); 29317 parseEndTag(endTagMatch[1], curIndex, index); 29318 continue 29319 } 29320 29321 // Start tag: 29322 var startTagMatch = parseStartTag(); 29323 if (startTagMatch) { 29324 handleStartTag(startTagMatch); 29325 if (shouldIgnoreFirstNewline(lastTag, html)) { 29326 advance(1); 29327 } 29328 continue 29329 } 29330 } 29331 29332 var text = (void 0), rest = (void 0), next = (void 0); 29333 if (textEnd >= 0) { 29334 rest = html.slice(textEnd); 29335 while ( 29336 !endTag.test(rest) && 29337 !startTagOpen.test(rest) && 29338 !comment.test(rest) && 29339 !conditionalComment.test(rest) 29340 ) { 29341 // < in plain text, be forgiving and treat it as text 29342 next = rest.indexOf('<', 1); 29343 if (next < 0) { break } 29344 textEnd += next; 29345 rest = html.slice(textEnd); 29346 } 29347 text = html.substring(0, textEnd); 29348 advance(textEnd); 29349 } 29350 29351 if (textEnd < 0) { 29352 text = html; 29353 html = ''; 29354 } 29355 29356 if (options.chars && text) { 29357 options.chars(text); 29358 } 29359 } else { 29360 var endTagLength = 0; 29361 var stackedTag = lastTag.toLowerCase(); 29362 var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')); 29363 var rest$1 = html.replace(reStackedTag, function (all, text, endTag) { 29364 endTagLength = endTag.length; 29365 if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') { 29366 text = text 29367 .replace(/<!--([\s\S]*?)-->/g, '$1') 29368 .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1'); 29369 } 29370 if (shouldIgnoreFirstNewline(stackedTag, text)) { 29371 text = text.slice(1); 29372 } 29373 if (options.chars) { 29374 options.chars(text); 29375 } 29376 return '' 29377 }); 29378 index += html.length - rest$1.length; 29379 html = rest$1; 29380 parseEndTag(stackedTag, index - endTagLength, index); 29381 } 29382 29383 if (html === last) { 29384 options.chars && options.chars(html); 29385 if ("development" !== 'production' && !stack.length && options.warn) { 29386 options.warn(("Mal-formatted tag at end of template: \"" + html + "\"")); 29387 } 29388 break 29389 } 29390 } 29391 29392 // Clean up any remaining tags 29393 parseEndTag(); 29394 29395 function advance (n) { 29396 index += n; 29397 html = html.substring(n); 29398 } 29399 29400 function parseStartTag () { 29401 var start = html.match(startTagOpen); 29402 if (start) { 29403 var match = { 29404 tagName: start[1], 29405 attrs: [], 29406 start: index 29407 }; 29408 advance(start[0].length); 29409 var end, attr; 29410 while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) { 29411 advance(attr[0].length); 29412 match.attrs.push(attr); 29413 } 29414 if (end) { 29415 match.unarySlash = end[1]; 29416 advance(end[0].length); 29417 match.end = index; 29418 return match 29419 } 29420 } 29421 } 29422 29423 function handleStartTag (match) { 29424 var tagName = match.tagName; 29425 var unarySlash = match.unarySlash; 29426 29427 if (expectHTML) { 29428 if (lastTag === 'p' && isNonPhrasingTag(tagName)) { 29429 parseEndTag(lastTag); 29430 } 29431 if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) { 29432 parseEndTag(tagName); 29433 } 29434 } 29435 29436 var unary = isUnaryTag$$1(tagName) || !!unarySlash; 29437 29438 var l = match.attrs.length; 29439 var attrs = new Array(l); 29440 for (var i = 0; i < l; i++) { 29441 var args = match.attrs[i]; 29442 // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778 29443 if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) { 29444 if (args[3] === '') { delete args[3]; } 29445 if (args[4] === '') { delete args[4]; } 29446 if (args[5] === '') { delete args[5]; } 29447 } 29448 var value = args[3] || args[4] || args[5] || ''; 29449 var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' 29450 ? options.shouldDecodeNewlinesForHref 29451 : options.shouldDecodeNewlines; 29452 attrs[i] = { 29453 name: args[1], 29454 value: decodeAttr(value, shouldDecodeNewlines) 29455 }; 29456 } 29457 29458 if (!unary) { 29459 stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs }); 29460 lastTag = tagName; 29461 } 29462 29463 if (options.start) { 29464 options.start(tagName, attrs, unary, match.start, match.end); 29465 } 29466 } 29467 29468 function parseEndTag (tagName, start, end) { 29469 var pos, lowerCasedTagName; 29470 if (start == null) { start = index; } 29471 if (end == null) { end = index; } 29472 29473 if (tagName) { 29474 lowerCasedTagName = tagName.toLowerCase(); 29475 } 29476 29477 // Find the closest opened tag of the same type 29478 if (tagName) { 29479 for (pos = stack.length - 1; pos >= 0; pos--) { 29480 if (stack[pos].lowerCasedTag === lowerCasedTagName) { 29481 break 29482 } 29483 } 29484 } else { 29485 // If no tag name is provided, clean shop 29486 pos = 0; 29487 } 29488 29489 if (pos >= 0) { 29490 // Close all the open elements, up the stack 29491 for (var i = stack.length - 1; i >= pos; i--) { 29492 if ("development" !== 'production' && 29493 (i > pos || !tagName) && 29494 options.warn 29495 ) { 29496 options.warn( 29497 ("tag <" + (stack[i].tag) + "> has no matching end tag.") 29498 ); 29499 } 29500 if (options.end) { 29501 options.end(stack[i].tag, start, end); 29502 } 29503 } 29504 29505 // Remove the open elements from the stack 29506 stack.length = pos; 29507 lastTag = pos && stack[pos - 1].tag; 29508 } else if (lowerCasedTagName === 'br') { 29509 if (options.start) { 29510 options.start(tagName, [], true, start, end); 29511 } 29512 } else if (lowerCasedTagName === 'p') { 29513 if (options.start) { 29514 options.start(tagName, [], false, start, end); 29515 } 29516 if (options.end) { 29517 options.end(tagName, start, end); 29518 } 29519 } 29520 } 29521} 29522 29523/* */ 29524 29525var onRE = /^@|^v-on:/; 29526var dirRE = /^v-|^@|^:/; 29527var forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/; 29528var forIteratorRE = /\((\{[^}]*\}|[^,]*),([^,]*)(?:,([^,]*))?\)/; 29529 29530var argRE = /:(.*)$/; 29531var bindRE = /^:|^v-bind:/; 29532var modifierRE = /\.[^.]+/g; 29533
29534var decodeHTMLCached = cached(he.decode); 29535 29536// configurable state 29537var warn$2; 29538var delimiters; 29539var transforms; 29540var preTransforms; 29541var postTransforms; 29542var platformIsPreTag; 29543var platformMustUseProp; 29544var platformGetTagNamespace; 29545 29546 29547 29548function createASTElement ( 29549 tag, 29550 attrs, 29551 parent 29552) { 29553 return { 29554 type: 1, 29555 tag: tag, 29556 attrsList: attrs, 29557 attrsMap: makeAttrsMap(attrs), 29558 parent: parent, 29559 children: [] 29560 } 29561} 29562 29563/** 29564 * Convert HTML string to AST. 29565 */ 29566function parse ( 29567 template, 29568 options 29569) { 29570 warn$2 = options.warn || baseWarn; 29571 29572 platformIsPreTag = options.isPreTag || no; 29573 platformMustUseProp = options.mustUseProp || no; 29574 platformGetTagNamespace = options.getTagNamespace || no; 29575 29576 transforms = pluckModuleFunction(options.modules, 'transformNode'); 29577 preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); 29578 postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); 29579 29580 delimiters = options.delimiters; 29581 29582 var stack = []; 29583 var preserveWhitespace = options.preserveWhitespace !== false; 29584 var root; 29585 var currentParent; 29586 var inVPre = false; 29587 var inPre = false; 29588 var warned = false; 29589 29590 function warnOnce (msg) { 29591 if (!warned) { 29592 warned = true; 29593 warn$2(msg); 29594 } 29595 } 29596 29597 function endPre (element) { 29598 // check pre state 29599 if (element.pre) { 29600 inVPre = false; 29601 } 29602 if (platformIsPreTag(element.tag)) { 29603 inPre = false; 29604 } 29605 } 29606 29607 parseHTML(template, { 29608 warn: warn$2, 29609 expectHTML: options.expectHTML, 29610 isUnaryTag: options.isUnaryTag, 29611 canBeLeftOpenTag: options.canBeLeftOpenTag, 29612 shouldDecodeNewlines: options.shouldDecodeNewlines, 29613 shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, 29614 shouldKeepComment: options.comments, 29615 start: function start (tag, attrs, unary) { 29616 // check namespace. 29617 // inherit parent ns if there is one 29618 var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); 29619 29620 // handle IE svg bug 29621 /* istanbul ignore if */ 29622 if (isIE && ns === 'svg') { 29623 attrs = guardIESVGBug(attrs); 29624 } 29625 29626 var element = createASTElement(tag, attrs, currentParent); 29627 if (ns) { 29628 element.ns = ns; 29629 } 29630 29631 if (isForbiddenTag(element) && !isServerRendering()) { 29632 element.forbidden = true; 29633 "development" !== 'production' && warn$2( 29634 'Templates should only be responsible for mapping the state to the ' + 29635 'UI. Avoid placing tags with side-effects in your templates, such as ' + 29636 "<" + tag + ">" + ', as they will not be parsed.' 29637 ); 29638 } 29639 29640 // apply pre-transforms 29641 for (var i = 0; i < preTransforms.length; i++) { 29642 element = preTransforms[i](element, options) || element; 29643 } 29644 29645 if (!inVPre) { 29646 processPre(element); 29647 if (element.pre) { 29648 inVPre = true; 29649 } 29650 } 29651 if (platformIsPreTag(element.tag)) { 29652 inPre = true; 29653 } 29654 if (inVPre) { 29655 processRawAttrs(element); 29656 } else if (!element.processed) { 29657 // structural directives 29658 processFor(element); 29659 processIf(element); 29660 processOnce(element); 29661 // element-scope stuff 29662 processElement(element, options); 29663 } 29664 29665 function checkRootConstraints (el) { 29666 { 29667 if (el.tag === 'slot' || el.tag === 'template') { 29668 warnOnce( 29669 "Cannot use <" + (el.tag) + "> as component root element because it may " + 29670 'contain multiple nodes.' 29671 ); 29672 } 29673 if (el.attrsMap.hasOwnProperty('v-for')) { 29674 warnOnce( 29675 'Cannot use v-for on stateful component root element because ' + 29676 'it renders multiple elements.' 29677 ); 29678 } 29679 } 29680 } 29681 29682 // tree management 29683 if (!root) { 29684 root = element; 29685 checkRootConstraints(root); 29686 } else if (!stack.length) { 29687 // allow root elements with v-if, v-else-if and v-else 29688 if (root.if && (element.elseif || element.else)) { 29689 checkRootConstraints(element); 29690 addIfCondition(root, { 29691 exp: element.elseif, 29692 block: element 29693 }); 29694 } else { 29695 warnOnce( 29696 "Component template should contain exactly one root element. " + 29697 "If you are using v-if on multiple elements, " + 29698 "use v-else-if to chain them instead." 29699 ); 29700 } 29701 } 29702 if (currentParent && !element.forbidden) { 29703 if (element.elseif || element.else) { 29704 processIfConditions(element, currentParent); 29705 } else if (element.slotScope) { // scoped slot 29706 currentParent.plain = false;
29707 var name = element.slotTarget || '"default"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element; 29708 } else { 29709 currentParent.children.push(element); 29710 element.parent = currentParent; 29711 } 29712 } 29713 if (!unary) { 29714 currentParent = element; 29715 stack.push(element); 29716 } else { 29717 endPre(element); 29718 } 29719 // apply post-transforms 29720 for (var i$1 = 0; i$1 < postTransforms.length; i$1++) { 29721 postTransforms[i$1](element, options); 29722 } 29723 }, 29724 29725 end: function end () { 29726 // remove trailing whitespace 29727 var element = stack[stack.length - 1]; 29728 var lastNode = element.children[element.children.length - 1]; 29729 if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) { 29730 element.children.pop(); 29731 } 29732 // pop stack 29733 stack.length -= 1; 29734 currentParent = stack[stack.length - 1]; 29735 endPre(element); 29736 }, 29737 29738 chars: function chars (text) { 29739 if (!currentParent) { 29740 { 29741 if (text === template) { 29742 warnOnce( 29743 'Component template requires a root element, rather than just text.' 29744 ); 29745 } else if ((text = text.trim())) { 29746 warnOnce( 29747 ("text \"" + text + "\" outside root element will be ignored.") 29748 ); 29749 } 29750 } 29751 return 29752 } 29753 // IE textarea placeholder bug 29754 /* istanbul ignore if */ 29755 if (isIE && 29756 currentParent.tag === 'textarea' && 29757 currentParent.attrsMap.placeholder === text 29758 ) { 29759 return 29760 } 29761 var children = currentParent.children; 29762 text = inPre || text.trim() 29763 ? isTextTag(currentParent) ? text : decodeHTMLCached(text) 29764 // only preserve whitespace if its not right after a starting tag 29765 : preserveWhitespace && children.length ? ' ' : ''; 29766 if (text) { 29767 var expression; 29768 if (!inVPre && text !== ' ' && (expression = parseText(text, delimiters))) { 29769 children.push({ 29770 type: 2, 29771 expression: expression, 29772 text: text 29773 }); 29774 } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') { 29775 children.push({ 29776 type: 3, 29777 text: text 29778 }); 29779 } 29780 } 29781 }, 29782 comment: function comment (text) { 29783 currentParent.children.push({ 29784 type: 3, 29785 text: text, 29786 isComment: true 29787 }); 29788 } 29789 }); 29790 return root 29791} 29792 29793function processPre (el) { 29794 if (getAndRemoveAttr(el, 'v-pre') != null) { 29795 el.pre = true; 29796 } 29797} 29798 29799function processRawAttrs (el) { 29800 var l = el.attrsList.length; 29801 if (l) { 29802 var attrs = el.attrs = new Array(l); 29803 for (var i = 0; i < l; i++) { 29804 attrs[i] = { 29805 name: el.attrsList[i].name, 29806 value: JSON.stringify(el.attrsList[i].value) 29807 }; 29808 } 29809 } else if (!el.pre) { 29810 // non root node in pre blocks with no attributes 29811 el.plain = true; 29812 } 29813} 29814 29815function processElement (element, options) { 29816 processKey(element); 29817 29818 // determine whether this is a plain element after 29819 // removing structural attributes 29820 element.plain = !element.key && !element.attrsList.length; 29821 29822 processRef(element); 29823 processSlot(element); 29824 processComponent(element); 29825 for (var i = 0; i < transforms.length; i++) { 29826 element = transforms[i](element, options) || element; 29827 } 29828 processAttrs(element); 29829} 29830 29831function processKey (el) { 29832 var exp = getBindingAttr(el, 'key'); 29833 if (exp) { 29834 if ("development" !== 'production' && el.tag === 'template') { 29835 warn$2("<template> cannot be keyed. Place the key on real elements instead."); 29836 } 29837 el.key = exp; 29838 } 29839} 29840 29841function processRef (el) { 29842 var ref = getBindingAttr(el, 'ref'); 29843 if (ref) { 29844 el.ref = ref; 29845 el.refInFor = checkInFor(el); 29846 } 29847} 29848 29849function processFor (el) { 29850 var exp; 29851 if ((exp = getAndRemoveAttr(el, 'v-for'))) { 29852 var inMatch = exp.match(forAliasRE); 29853 if (!inMatch) { 29854 "development" !== 'production' && warn$2( 29855 ("Invalid v-for expression: " + exp) 29856 ); 29857 return 29858 } 29859 el.for = inMatch[2].trim(); 29860 var alias = inMatch[1].trim(); 29861 var iteratorMatch = alias.match(forIteratorRE); 29862 if (iteratorMatch) { 29863 el.alias = iteratorMatch[1].trim(); 29864 el.iterator1 = iteratorMatch[2].trim(); 29865 if (iteratorMatch[3]) { 29866 el.iterator2 = iteratorMatch[3].trim(); 29867 } 29868 } else { 29869 el.alias = alias; 29870 } 29871 } 29872} 29873 29874function processIf (el) { 29875 var exp = getAndRemoveAttr(el, 'v-if'); 29876 if (exp) { 29877 el.if = exp; 29878 addIfCondition(el, { 29879 exp: exp, 29880 block: el 29881 }); 29882 } else { 29883 if (getAndRemoveAttr(el, 'v-else') != null) { 29884 el.else = true; 29885 } 29886 var elseif = getAndRemoveAttr(el, 'v-else-if'); 29887 if (elseif) { 29888 el.elseif = elseif; 29889 } 29890 } 29891} 29892 29893function processIfConditions (el, parent) { 29894 var prev = findPrevElement(parent.children); 29895 if (prev && prev.if) { 29896 addIfCondition(prev, { 29897 exp: el.elseif, 29898 block: el 29899 }); 29900 } else { 29901 warn$2( 29902 "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " + 29903 "used on element <" + (el.tag) + "> without corresponding v-if." 29904 ); 29905 } 29906} 29907 29908function findPrevElement (children) { 29909 var i = children.length; 29910 while (i--) { 29911 if (children[i].type === 1) { 29912 return children[i] 29913 } else { 29914 if ("development" !== 'production' && children[i].text !== ' ') { 29915 warn$2( 29916 "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " + 29917 "will be ignored." 29918 ); 29919 } 29920 children.pop(); 29921 } 29922 } 29923} 29924 29925function addIfCondition (el, condition) { 29926 if (!el.ifConditions) { 29927 el.ifConditions = []; 29928 } 29929 el.ifConditions.push(condition); 29930} 29931 29932function processOnce (el) { 29933 var once$$1 = getAndRemoveAttr(el, 'v-once'); 29934 if (once$$1 != null) { 29935 el.once = true; 29936 } 29937} 29938 29939function processSlot (el) { 29940 if (el.tag === 'slot') { 29941 el.slotName = getBindingAttr(el, 'name'); 29942 if ("development" !== 'production' && el.key) { 29943 warn$2( 29944 "`key` does not work on <slot> because slots are abstract outlets " + 29945 "and can possibly expand into multiple elements. " + 29946 "Use the key on a wrapping element instead." 29947 ); 29948 } 29949 } else { 29950 var slotScope; 29951 if (el.tag === 'template') { 29952 slotScope = getAndRemoveAttr(el, 'scope'); 29953 /* istanbul ignore if */ 29954 if ("development" !== 'production' && slotScope) { 29955 warn$2( 29956 "the \"scope\" attribute for scoped slots have been deprecated and " + 29957 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " + 29958 "can also be used on plain elements in addition to <template> to " + 29959 "denote scoped slots.", 29960 true 29961 ); 29962 } 29963 el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope'); 29964 } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { 29965 /* istanbul ignore if */ 29966 if ("development" !== 'production' && el.attrsMap['v-for']) { 29967 warn$2( 29968 "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " + 29969 "(v-for takes higher priority). Use a wrapper <template> for the " + 29970 "scoped slot to make it clearer.", 29971 true 29972 ); 29973 } 29974 el.slotScope = slotScope; 29975 } 29976 var slotTarget = getBindingAttr(el, 'slot'); 29977 if (slotTarget) { 29978 el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; 29979 // preserve slot as an attribute for native shadow DOM compat 29980 // only for non-scoped slots. 29981 if (el.tag !== 'template' && !el.slotScope) { 29982 addAttr(el, 'slot', slotTarget); 29983 } 29984 } 29985 } 29986} 29987 29988function processComponent (el) { 29989 var binding; 29990 if ((binding = getBindingAttr(el, 'is'))) { 29991 el.component = binding; 29992 } 29993 if (getAndRemoveAttr(el, 'inline-template') != null) { 29994 el.inlineTemplate = true; 29995 } 29996} 29997 29998function processAttrs (el) { 29999 var list = el.attrsList; 30000 var i, l, name, rawName, value, modifiers, isProp; 30001 for (i = 0, l = list.length; i < l; i++) { 30002 name = rawName = list[i].name; 30003 value = list[i].value; 30004 if (dirRE.test(name)) { 30005 // mark element as dynamic 30006 el.hasBindings = true; 30007 // modifiers 30008 modifiers = parseModifiers(name); 30009 if (modifiers) { 30010 name = name.replace(modifierRE, ''); 30011 } 30012 if (bindRE.test(name)) { // v-bind 30013 name = name.replace(bindRE, ''); 30014 value = parseFilters(value); 30015 isProp = false;
30016 if (modifiers) { 30017 if (modifiers.prop) { 30018 isProp = true; 30019 name = camelize(name); 30020 if (name === 'innerHtml') { name = 'innerHTML'; } 30021 } 30022 if (modifiers.camel) { 30023 name = camelize(name); 30024 } 30025 if (modifiers.sync) { 30026 addHandler( 30027 el, 30028 ("update:" + (camelize(name))), 30029 genAssignmentCode(value, "$event") 30030 ); 30031 } 30032 } 30033 if (isProp || ( 30034 !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name) 30035 )) { 30036 addProp(el, name, value); 30037 } else { 30038 addAttr(el, name, value); 30039 } 30040 } else if (onRE.test(name)) { // v-on 30041 name = name.replace(onRE, ''); 30042 addHandler(el, name, value, modifiers, false, warn$2); 30043 } else { // normal directives 30044 name = name.replace(dirRE, ''); 30045 // parse arg 30046 var argMatch = name.match(argRE); 30047 var arg = argMatch && argMatch[1]; 30048 if (arg) { 30049 name = name.slice(0, -(arg.length + 1)); 30050 } 30051 addDirective(el, name, rawName, value, arg, modifiers); 30052 if ("development" !== 'production' && name === 'model') { 30053 checkForAliasModel(el, value); 30054 } 30055 } 30056 } else { 30057 // literal attribute 30058 { 30059 var expression = parseText(value, delimiters); 30060 if (expression) { 30061 warn$2( 30062 name + "=\"" + value + "\": " + 30063 'Interpolation inside attributes has been removed. ' + 30064 'Use v-bind or the colon shorthand instead. For example, ' + 30065 'instead of <div id="{{ val }}">, use <div :id="val">.' 30066 ); 30067 } 30068 } 30069 addAttr(el, name, JSON.stringify(value)); 30070 // #6887 firefox doesn't update muted state if set via attribute 30071 // even immediately after element creation 30072 if (!el.component && 30073 name === 'muted' && 30074 platformMustUseProp(el.tag, el.attrsMap.type, name)) { 30075 addProp(el, name, 'true'); 30076 } 30077 } 30078 } 30079} 30080 30081function checkInFor (el) { 30082 var parent = el; 30083 while (parent) { 30084 if (parent.for !== undefined) { 30085 return true 30086 } 30087 parent = parent.parent; 30088 } 30089 return false 30090} 30091 30092function parseModifiers (name) { 30093 var match = name.match(modifierRE); 30094 if (match) { 30095 var ret = {}; 30096 match.forEach(function (m) { ret[m.slice(1)] = true; }); 30097 return ret 30098 } 30099} 30100 30101function makeAttrsMap (attrs) { 30102 var map = {}; 30103 for (var i = 0, l = attrs.length; i < l; i++) { 30104 if ( 30105 "development" !== 'production' && 30106 map[attrs[i].name] && !isIE && !isEdge 30107 ) { 30108 warn$2('duplicate attribute: ' + attrs[i].name); 30109 } 30110 map[attrs[i].name] = attrs[i].value; 30111 } 30112 return map 30113} 30114 30115// for script (e.g. type="x/template") or style, do not decode content 30116function isTextTag (el) { 30117 return el.tag === 'script' || el.tag === 'style' 30118} 30119 30120function isForbiddenTag (el) { 30121 return ( 30122 el.tag === 'style' || 30123 (el.tag === 'script' && ( 30124 !el.attrsMap.type || 30125 el.attrsMap.type === 'text/javascript' 30126 )) 30127 ) 30128} 30129 30130var ieNSBug = /^xmlns:NS\d+/; 30131var ieNSPrefix = /^NS\d+:/; 30132 30133/* istanbul ignore next */ 30134function guardIESVGBug (attrs) { 30135 var res = []; 30136 for (var i = 0; i < attrs.length; i++) { 30137 var attr = attrs[i]; 30138 if (!ieNSBug.test(attr.name)) { 30139 attr.name = attr.name.replace(ieNSPrefix, ''); 30140 res.push(attr); 30141 } 30142 } 30143 return res 30144} 30145 30146function checkForAliasModel (el, value) { 30147 var _el = el; 30148 while (_el) { 30149 if (_el.for && _el.alias === value) { 30150 warn$2( 30151 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 30152 "You are binding v-model directly to a v-for iteration alias. " + 30153 "This will not be able to modify the v-for source array because " + 30154 "writing to the alias is like modifying a function local variable. " + 30155 "Consider using an array of objects and use v-model on an object property instead." 30156 ); 30157 } 30158 _el = _el.parent; 30159 } 30160} 30161 30162/* */ 30163 30164/** 30165 * Expand input[v-model] with dyanmic type bindings into v-if-else chains 30166 * Turn this: 30167 * <input v-model="data[type]" :type="type"> 30168 * into this: 30169 * <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]"> 30170 * <input v-else-if="type === 'radio'" type="radio" v-model="data[type]"> 30171 * <input v-else :type="type" v-model="data[type]"> 30172 */ 30173 30174function preTransformNode (el, options) { 30175 if (el.tag === 'input') { 30176 var map = el.attrsMap; 30177 if (map['v-model'] && (map['v-bind:type'] || map[':type'])) { 30178 var typeBinding = getBindingAttr(el, 'type'); 30179 var ifCondition = getAndRemoveAttr(el, 'v-if', true); 30180 var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : ""; 30181 var hasElse = getAndRemoveAttr(el, 'v-else', true) != null; 30182 var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); 30183 // 1. checkbox 30184 var branch0 = cloneASTElement(el); 30185 // process for on the main node 30186 processFor(branch0); 30187 addRawAttr(branch0, 'type', 'checkbox'); 30188 processElement(branch0, options); 30189 branch0.processed = true; // prevent it from double-processed 30190 branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra; 30191 addIfCondition(branch0, { 30192 exp: branch0.if, 30193 block: branch0 30194 }); 30195 // 2. add radio else-if condition 30196 var branch1 = cloneASTElement(el); 30197 getAndRemoveAttr(branch1, 'v-for', true); 30198 addRawAttr(branch1, 'type', 'radio'); 30199 processElement(branch1, options); 30200 addIfCondition(branch0, { 30201 exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra, 30202 block: branch1 30203 }); 30204 // 3. other 30205 var branch2 = cloneASTElement(el); 30206 getAndRemoveAttr(branch2, 'v-for', true); 30207 addRawAttr(branch2, ':type', typeBinding); 30208 processElement(branch2, options); 30209 addIfCondition(branch0, { 30210 exp: ifCondition, 30211 block: branch2 30212 }); 30213 30214 if (hasElse) { 30215 branch0.else = true; 30216 } else if (elseIfCondition) { 30217 branch0.elseif = elseIfCondition; 30218 } 30219 30220 return branch0 30221 } 30222 } 30223} 30224 30225function cloneASTElement (el) { 30226 return createASTElement(el.tag, el.attrsList.slice(), el.parent) 30227} 30228 30229function addRawAttr (el, name, value) { 30230 el.attrsMap[name] = value; 30231 el.attrsList.push({ name: name, value: value }); 30232} 30233 30234var model$2 = { 30235 preTransformNode: preTransformNode 30236}; 30237 30238var modules$1 = [ 30239 klass$1, 30240 style$1, 30241 model$2 30242]; 30243 30244/* */ 30245 30246function text (el, dir) { 30247 if (dir.value) { 30248 addProp(el, 'textContent', ("_s(" + (dir.value) + ")")); 30249 } 30250} 30251 30252/* */ 30253 30254function html (el, dir) { 30255 if (dir.value) { 30256 addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")")); 30257 } 30258} 30259 30260var directives$1 = { 30261 model: model, 30262 text: text, 30263 html: html 30264}; 30265 30266/* */ 30267 30268var baseOptions = { 30269 expectHTML: true, 30270 modules: modules$1, 30271 directives: directives$1, 30272 isPreTag: isPreTag, 30273 isUnaryTag: isUnaryTag, 30274 mustUseProp: mustUseProp, 30275 canBeLeftOpenTag: canBeLeftOpenTag, 30276 isReservedTag: isReservedTag, 30277 getTagNamespace: getTagNamespace, 30278 staticKeys: genStaticKeys(modules$1) 30279}; 30280 30281/* */ 30282 30283var isStaticKey; 30284var isPlatformReservedTag; 30285
30286var genStaticKeysCached = cached(genStaticKeys$1); 30287 30288/** 30289 * Goal of the optimizer: walk the generated template AST tree 30290 * and detect sub-trees that are purely static, i.e. parts of 30291 * the DOM that never needs to change. 30292 * 30293 * Once we detect these sub-trees, we can: 30294 * 30295 * 1. Hoist them into constants, so that we no longer need to 30296 * create fresh nodes for them on each re-render; 30297 * 2. Completely skip them in the patching process. 30298 */ 30299function optimize (root, options) { 30300 if (!root) { return } 30301 isStaticKey = genStaticKeysCached(options.staticKeys || ''); 30302 isPlatformReservedTag = options.isReservedTag || no; 30303 // first pass: mark all non-static nodes. 30304 markStatic$1(root); 30305 // second pass: mark static roots. 30306 markStaticRoots(root, false); 30307} 30308 30309function genStaticKeys$1 (keys) { 30310 return makeMap( 30311 'type,tag,attrsList,attrsMap,plain,parent,children,attrs' + 30312 (keys ? ',' + keys : '') 30313 ) 30314} 30315 30316function markStatic$1 (node) { 30317 node.static = isStatic(node); 30318 if (node.type === 1) { 30319 // do not make component slot content static. this avoids 30320 // 1. components not able to mutate slot nodes 30321 // 2. static slot content fails for hot-reloading 30322 if ( 30323 !isPlatformReservedTag(node.tag) && 30324 node.tag !== 'slot' && 30325 node.attrsMap['inline-template'] == null 30326 ) { 30327 return 30328 } 30329 for (var i = 0, l = node.children.length; i < l; i++) { 30330 var child = node.children[i]; 30331 markStatic$1(child); 30332 if (!child.static) { 30333 node.static = false; 30334 } 30335 } 30336 if (node.ifConditions) { 30337 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 30338 var block = node.ifConditions[i$1].block; 30339 markStatic$1(block); 30340 if (!block.static) { 30341 node.static = false; 30342 } 30343 } 30344 } 30345 } 30346} 30347 30348function markStaticRoots (node, isInFor) { 30349 if (node.type === 1) { 30350 if (node.static || node.once) { 30351 node.staticInFor = isInFor; 30352 } 30353 // For a node to qualify as a static root, it should have children that 30354 // are not just static text. Otherwise the cost of hoisting out will 30355 // outweigh the benefits and it's better off to just always render it fresh. 30356 if (node.static && node.children.length && !( 30357 node.children.length === 1 && 30358 node.children[0].type === 3 30359 )) { 30360 node.staticRoot = true; 30361 return 30362 } else { 30363 node.staticRoot = false; 30364 } 30365 if (node.children) { 30366 for (var i = 0, l = node.children.length; i < l; i++) { 30367 markStaticRoots(node.children[i], isInFor || !!node.for); 30368 } 30369 } 30370 if (node.ifConditions) { 30371 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 30372 markStaticRoots(node.ifConditions[i$1].block, isInFor); 30373 } 30374 } 30375 } 30376} 30377 30378function isStatic (node) { 30379 if (node.type === 2) { // expression 30380 return false 30381 } 30382 if (node.type === 3) { // text 30383 return true 30384 } 30385 return !!(node.pre || ( 30386 !node.hasBindings && // no dynamic bindings 30387 !node.if && !node.for && // not v-if or v-for or v-else 30388 !isBuiltInTag(node.tag) && // not a built-in 30389 isPlatformReservedTag(node.tag) && // not a component 30390 !isDirectChildOfTemplateFor(node) && 30391 Object.keys(node).every(isStaticKey) 30392 )) 30393} 30394 30395function isDirectChildOfTemplateFor (node) { 30396 while (node.parent) { 30397 node = node.parent; 30398 if (node.tag !== 'template') { 30399 return false 30400 } 30401 if (node.for) { 30402 return true 30403 } 30404 } 30405 return false 30406} 30407 30408/* */ 30409 30410var fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/; 30411var simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?']|\[".*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*\s*$/; 30412 30413// keyCode aliases 30414var keyCodes = { 30415 esc: 27, 30416 tab: 9, 30417 enter: 13, 30418 space: 32, 30419 up: 38, 30420 left: 37, 30421 right: 39, 30422 down: 40, 30423 'delete': [8, 46] 30424}; 30425 30426// #4868: modifiers that prevent the execution of the listener 30427// need to explicitly return null so that we can determine whether to remove 30428// the listener for .once 30429var genGuard = function (condition) { return ("if(" + condition + ")return null;"); }; 30430 30431var modifierCode = { 30432 stop: '$event.stopPropagation();', 30433 prevent: '$event.preventDefault();', 30434 self: genGuard("$event.target !== $event.currentTarget"), 30435 ctrl: genGuard("!$event.ctrlKey"), 30436 shift: genGuard("!$event.shiftKey"), 30437 alt: genGuard("!$event.altKey"), 30438 meta: genGuard("!$event.metaKey"), 30439 left: genGuard("'button' in $event && $event.button !== 0"), 30440 middle: genGuard("'button' in $event && $event.button !== 1"), 30441 right: genGuard("'button' in $event && $event.button !== 2") 30442}; 30443 30444function genHandlers ( 30445 events, 30446 isNative, 30447 warn 30448) { 30449 var res = isNative ? 'nativeOn:{' : 'on:{'; 30450 for (var name in events) { 30451 res += "\"" + name + "\":" + (genHandler(name, events[name])) + ","; 30452 } 30453 return res.slice(0, -1) + '}' 30454} 30455 30456function genHandler ( 30457 name, 30458 handler 30459) { 30460 if (!handler) { 30461 return 'function(){}' 30462 } 30463 30464 if (Array.isArray(handler)) { 30465 return ("[" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + "]") 30466 } 30467 30468 var isMethodPath = simplePathRE.test(handler.value); 30469 var isFunctionExpression = fnExpRE.test(handler.value); 30470 30471 if (!handler.modifiers) { 30472 return isMethodPath || isFunctionExpression 30473 ? handler.value 30474 : ("function($event){" + (handler.value) + "}") // inline statement 30475 } else { 30476 var code = ''; 30477 var genModifierCode = ''; 30478 var keys = []; 30479 for (var key in handler.modifiers) { 30480 if (modifierCode[key]) { 30481 genModifierCode += modifierCode[key]; 30482 // left/right 30483 if (keyCodes[key]) { 30484 keys.push(key); 30485 } 30486 } else if (key === 'exact') { 30487 var modifiers = (handler.modifiers); 30488 genModifierCode += genGuard( 30489 ['ctrl', 'shift', 'alt', 'meta'] 30490 .filter(function (keyModifier) { return !modifiers[keyModifier]; }) 30491 .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); }) 30492 .join('||') 30493 ); 30494 } else { 30495 keys.push(key); 30496 } 30497 } 30498 if (keys.length) { 30499 code += genKeyFilter(keys); 30500 } 30501 // Make sure modifiers like prevent and stop get executed after key filtering 30502 if (genModifierCode) { 30503 code += genModifierCode; 30504 } 30505 var handlerCode = isMethodPath 30506 ? handler.value + '($event)' 30507 : isFunctionExpression 30508 ? ("(" + (handler.value) + ")($event)") 30509 : handler.value; 30510 return ("function($event){" + code + handlerCode + "}") 30511 } 30512} 30513 30514function genKeyFilter (keys) { 30515 return ("if(!('button' in $event)&&" + (keys.map(genFilterCode).join('&&')) + ")return null;") 30516} 30517 30518function genFilterCode (key) { 30519 var keyVal = parseInt(key, 10); 30520 if (keyVal) { 30521 return ("$event.keyCode!==" + keyVal) 30522 } 30523 var code = keyCodes[key]; 30524 return ( 30525 "_k($event.keyCode," + 30526 (JSON.stringify(key)) + "," + 30527 (JSON.stringify(code)) + "," + 30528 "$event.key)" 30529 ) 30530} 30531 30532/* */ 30533 30534function on (el, dir) { 30535 if ("development" !== 'production' && dir.modifiers) { 30536 warn("v-on without argument does not support modifiers."); 30537 } 30538 el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); }; 30539} 30540 30541/* */ 30542 30543function bind$1 (el, dir) { 30544 el.wrapData = function (code) { 30545 return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")") 30546 }; 30547} 30548 30549/* */ 30550 30551var baseDirectives = { 30552 on: on, 30553 bind: bind$1, 30554 cloak: noop 30555}; 30556 30557/* */ 30558 30559var CodegenState = function CodegenState (options) { 30560 this.options = options; 30561 this.warn = options.warn || baseWarn; 30562 this.transforms = pluckModuleFunction(options.modules, 'transformCode'); 30563 this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); 30564 this.directives = extend(extend({}, baseDirectives), options.directives); 30565 var isReservedTag = options.isReservedTag || no; 30566 this.maybeComponent = function (el) { return !isReservedTag(el.tag); }; 30567 this.onceId = 0; 30568 this.staticRenderFns = []; 30569}; 30570 30571 30572 30573function generate ( 30574 ast, 30575 options 30576) { 30577 var state = new CodegenState(options); 30578 var code = ast ? genElement(ast, state) : '_c("div")'; 30579 return { 30580 render: ("with(this){return " + code + "}"), 30581 staticRenderFns: state.staticRenderFns 30582 } 30583} 30584 30585function genElement (el, state) { 30586 if (el.staticRoot && !el.staticProcessed) { 30587 return genStatic(el, state) 30588 } else if (el.once && !el.onceProcessed) { 30589 return genOnce(el, state) 30590 } else if (el.for && !el.forProcessed) { 30591 return genFor(el, state) 30592 } else if (el.if && !el.ifProcessed) { 30593 return genIf(el, state) 30594 } else if (el.tag === 'template' && !el.slotTarget) { 30595 return genChildren(el, state) || 'void 0' 30596 } else if (el.tag === 'slot') { 30597 return genSlot(el, state) 30598 } else { 30599 // component or element 30600 var code; 30601 if (el.component) { 30602 code = genComponent(el.component, el, state); 30603 } else { 30604 var data = el.plain ? undefined : genData$2(el, state); 30605 30606 var children = el.inlineTemplate ? null : genChildren(el, state, true);
30607 code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")"; 30608 } 30609 // module transforms 30610 for (var i = 0; i < state.transforms.length; i++) { 30611 code = state.transforms[i](el, code); 30612 } 30613 return code 30614 } 30615} 30616 30617// hoist static sub-trees out 30618function genStatic (el, state, once$$1) { 30619 el.staticProcessed = true; 30620 state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}")); 30621 return ("_m(" + (state.staticRenderFns.length - 1) + "," + (el.staticInFor ? 'true' : 'false') + "," + (once$$1 ? 'true' : 'false') + ")") 30622} 30623 30624// v-once 30625function genOnce (el, state) { 30626 el.onceProcessed = true; 30627 if (el.if && !el.ifProcessed) { 30628 return genIf(el, state) 30629 } else if (el.staticInFor) { 30630 var key = ''; 30631 var parent = el.parent; 30632 while (parent) { 30633 if (parent.for) { 30634 key = parent.key; 30635 break 30636 } 30637 parent = parent.parent; 30638 } 30639 if (!key) { 30640 "development" !== 'production' && state.warn( 30641 "v-once can only be used inside v-for that is keyed. " 30642 ); 30643 return genElement(el, state) 30644 } 30645 return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")") 30646 } else { 30647 return genStatic(el, state, true) 30648 } 30649} 30650 30651function genIf ( 30652 el, 30653 state, 30654 altGen, 30655 altEmpty 30656) { 30657 el.ifProcessed = true; // avoid recursion 30658 return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty) 30659} 30660 30661function genIfConditions ( 30662 conditions, 30663 state, 30664 altGen, 30665 altEmpty 30666) { 30667 if (!conditions.length) { 30668 return altEmpty || '_e()' 30669 } 30670 30671 var condition = conditions.shift(); 30672 if (condition.exp) { 30673 return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty))) 30674 } else { 30675 return ("" + (genTernaryExp(condition.block))) 30676 } 30677 30678 // v-if with v-once should generate code like (a)?_m(0):_m(1) 30679 function genTernaryExp (el) { 30680 return altGen 30681 ? altGen(el, state) 30682 : el.once 30683 ? genOnce(el, state) 30684 : genElement(el, state) 30685 } 30686} 30687 30688function genFor ( 30689 el, 30690 state, 30691 altGen, 30692 altHelper 30693) { 30694 var exp = el.for; 30695 var alias = el.alias; 30696 var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; 30697 var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; 30698 30699 if ("development" !== 'production' && 30700 state.maybeComponent(el) && 30701 el.tag !== 'slot' && 30702 el.tag !== 'template' && 30703 !el.key 30704 ) { 30705 state.warn( 30706 "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " + 30707 "v-for should have explicit keys. " + 30708 "See https://vuejs.org/guide/list.html#key for more info.", 30709 true /* tip */ 30710 ); 30711 } 30712 30713 el.forProcessed = true; // avoid recursion 30714 return (altHelper || '_l') + "((" + exp + ")," + 30715 "function(" + alias + iterator1 + iterator2 + "){" + 30716 "return " + ((altGen || genElement)(el, state)) + 30717 '})' 30718} 30719 30720function genData$2 (el, state) { 30721 var data = '{'; 30722 30723 // directives first. 30724 // directives may mutate the el's other properties before they are generated. 30725 var dirs = genDirectives(el, state); 30726 if (dirs) { data += dirs + ','; } 30727 30728 // key 30729 if (el.key) { 30730 data += "key:" + (el.key) + ","; 30731 } 30732 // ref 30733 if (el.ref) { 30734 data += "ref:" + (el.ref) + ","; 30735 } 30736 if (el.refInFor) { 30737 data += "refInFor:true,"; 30738 } 30739 // pre 30740 if (el.pre) { 30741 data += "pre:true,"; 30742 } 30743 // record original tag name for components using "is" attribute 30744 if (el.component) { 30745 data += "tag:\"" + (el.tag) + "\","; 30746 } 30747 // module data generation functions 30748 for (var i = 0; i < state.dataGenFns.length; i++) { 30749 data += state.dataGenFns[i](el); 30750 } 30751 // attributes 30752 if (el.attrs) { 30753 data += "attrs:{" + (genProps(el.attrs)) + "},"; 30754 } 30755 // DOM props 30756 if (el.props) { 30757 data += "domProps:{" + (genProps(el.props)) + "},"; 30758 } 30759 // event handlers 30760 if (el.events) { 30761 data += (genHandlers(el.events, false, state.warn)) + ","; 30762 } 30763 if (el.nativeEvents) { 30764 data += (genHandlers(el.nativeEvents, true, state.warn)) + ","; 30765 } 30766 // slot target 30767 // only for non-scoped slots 30768 if (el.slotTarget && !el.slotScope) { 30769 data += "slot:" + (el.slotTarget) + ","; 30770 } 30771 // scoped slots 30772 if (el.scopedSlots) { 30773 data += (genScopedSlots(el.scopedSlots, state)) + ","; 30774 } 30775 // component v-model 30776 if (el.model) { 30777 data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},"; 30778 } 30779 // inline-template 30780 if (el.inlineTemplate) { 30781 var inlineTemplate = genInlineTemplate(el, state); 30782 if (inlineTemplate) { 30783 data += inlineTemplate + ","; 30784 } 30785 } 30786 data = data.replace(/,$/, '') + '}'; 30787 // v-bind data wrap 30788 if (el.wrapData) { 30789 data = el.wrapData(data); 30790 } 30791 // v-on data wrap 30792 if (el.wrapListeners) { 30793 data = el.wrapListeners(data); 30794 } 30795 return data 30796} 30797 30798function genDirectives (el, state) { 30799 var dirs = el.directives; 30800 if (!dirs) { return } 30801 var res = 'directives:['; 30802 var hasRuntime = false;
30803 var i, l, dir, needRuntime; 30804 for (i = 0, l = dirs.length; i < l; i++) { 30805 dir = dirs[i]; 30806 needRuntime = true; 30807 var gen = state.directives[dir.name]; 30808 if (gen) { 30809 // compile-time directive that manipulates AST. 30810 // returns true if it also needs a runtime counterpart. 30811 needRuntime = !!gen(el, dir, state.warn); 30812 } 30813 if (needRuntime) { 30814 hasRuntime = true; 30815 res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:\"" + (dir.arg) + "\"") : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},"; 30816 } 30817 } 30818 if (hasRuntime) { 30819 return res.slice(0, -1) + ']' 30820 } 30821} 30822 30823function genInlineTemplate (el, state) { 30824 var ast = el.children[0]; 30825 if ("development" !== 'production' && ( 30826 el.children.length !== 1 || ast.type !== 1 30827 )) { 30828 state.warn('Inline-template components must have exactly one child element.'); 30829 } 30830 if (ast.type === 1) { 30831 var inlineRenderFns = generate(ast, state.options); 30832 return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}") 30833 } 30834} 30835 30836function genScopedSlots ( 30837 slots, 30838 state 30839) { 30840 return ("scopedSlots:_u([" + (Object.keys(slots).map(function (key) { 30841 return genScopedSlot(key, slots[key], state) 30842 }).join(',')) + "])") 30843} 30844 30845function genScopedSlot ( 30846 key, 30847 el, 30848 state 30849) { 30850 if (el.for && !el.forProcessed) { 30851 return genForScopedSlot(key, el, state) 30852 } 30853 var fn = "function(" + (String(el.slotScope)) + "){" + 30854 "return " + (el.tag === 'template' 30855 ? el.if 30856 ? ((el.if) + "?" + (genChildren(el, state) || 'undefined') + ":undefined") 30857 : genChildren(el, state) || 'undefined' 30858 : genElement(el, state)) + "}"; 30859 return ("{key:" + key + ",fn:" + fn + "}") 30860} 30861 30862function genForScopedSlot ( 30863 key, 30864 el, 30865 state 30866) { 30867 var exp = el.for; 30868 var alias = el.alias; 30869 var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; 30870 var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; 30871 el.forProcessed = true; // avoid recursion 30872 return "_l((" + exp + ")," + 30873 "function(" + alias + iterator1 + iterator2 + "){" + 30874 "return " + (genScopedSlot(key, el, state)) + 30875 '})' 30876} 30877 30878function genChildren ( 30879 el, 30880 state, 30881 checkSkip, 30882 altGenElement, 30883 altGenNode 30884) { 30885 var children = el.children; 30886 if (children.length) { 30887 var el$1 = children[0]; 30888 // optimize single v-for 30889 if (children.length === 1 && 30890 el$1.for && 30891 el$1.tag !== 'template' && 30892 el$1.tag !== 'slot' 30893 ) { 30894 return (altGenElement || genElement)(el$1, state) 30895 } 30896 var normalizationType = checkSkip 30897 ? getNormalizationType(children, state.maybeComponent) 30898 : 0; 30899 var gen = altGenNode || genNode; 30900 return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType ? ("," + normalizationType) : '')) 30901 } 30902} 30903 30904// determine the normalization needed for the children array. 30905// 0: no normalization needed 30906// 1: simple normalization needed (possible 1-level deep nested array) 30907// 2: full normalization needed 30908function getNormalizationType ( 30909 children, 30910 maybeComponent 30911) { 30912 var res = 0; 30913 for (var i = 0; i < children.length; i++) { 30914 var el = children[i]; 30915 if (el.type !== 1) { 30916 continue 30917 } 30918 if (needsNormalization(el) || 30919 (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) { 30920 res = 2; 30921 break 30922 } 30923 if (maybeComponent(el) || 30924 (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) { 30925 res = 1; 30926 } 30927 } 30928 return res 30929} 30930 30931function needsNormalization (el) { 30932 return el.for !== undefined || el.tag === 'template' || el.tag === 'slot' 30933} 30934 30935function genNode (node, state) { 30936 if (node.type === 1) { 30937 return genElement(node, state) 30938 } if (node.type === 3 && node.isComment) { 30939 return genComment(node) 30940 } else { 30941 return genText(node) 30942 } 30943} 30944 30945function genText (text) { 30946 return ("_v(" + (text.type === 2 30947 ? text.expression // no need for () because already wrapped in _s() 30948 : transformSpecialNewlines(JSON.stringify(text.text))) + ")") 30949} 30950 30951function genComment (comment) { 30952 return ("_e(" + (JSON.stringify(comment.text)) + ")") 30953} 30954 30955function genSlot (el, state) { 30956 var slotName = el.slotName || '"default"'; 30957 var children = genChildren(el, state); 30958 var res = "_t(" + slotName + (children ? ("," + children) : ''); 30959 var attrs = el.attrs && ("{" + (el.attrs.map(function (a) { return ((camelize(a.name)) + ":" + (a.value)); }).join(',')) + "}"); 30960 var bind$$1 = el.attrsMap['v-bind']; 30961 if ((attrs || bind$$1) && !children) { 30962 res += ",null"; 30963 } 30964 if (attrs) { 30965 res += "," + attrs; 30966 } 30967 if (bind$$1) { 30968 res += (attrs ? '' : ',null') + "," + bind$$1; 30969 } 30970 return res + ')' 30971} 30972 30973// componentName is el.component, take it as argument to shun flow's pessimistic refinement 30974function genComponent ( 30975 componentName, 30976 el, 30977 state 30978) { 30979 var children = el.inlineTemplate ? null : genChildren(el, state, true); 30980 return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")") 30981} 30982 30983function genProps (props) { 30984 var res = ''; 30985 for (var i = 0; i < props.length; i++) { 30986 var prop = props[i]; 30987 res += "\"" + (prop.name) + "\":" + (transformSpecialNewlines(prop.value)) + ","; 30988 } 30989 return res.slice(0, -1) 30990} 30991 30992// #3895, #4268 30993function transformSpecialNewlines (text) { 30994 return text 30995 .replace(/\u2028/g, '\\u2028') 30996 .replace(/\u2029/g, '\\u2029') 30997} 30998 30999/* */ 31000 31001// these keywords should not appear inside expressions, but operators like 31002// typeof, instanceof and in are allowed 31003var prohibitedKeywordRE = new RegExp('\\b' + ( 31004 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 31005 'super,throw,while,yield,delete,export,import,return,switch,default,' + 31006 'extends,finally,continue,debugger,function,arguments' 31007).split(',').join('\\b|\\b') + '\\b'); 31008 31009// these unary operators should not be used as property/method names 31010var unaryOperatorsRE = new RegExp('\\b' + ( 31011 'delete,typeof,void' 31012).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)'); 31013 31014// strip strings in expressions 31015var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 31016 31017// detect problematic expressions in a template 31018function detectErrors (ast) { 31019 var errors = []; 31020 if (ast) { 31021 checkNode(ast, errors); 31022 } 31023 return errors 31024} 31025 31026function checkNode (node, errors) { 31027 if (node.type === 1) { 31028 for (var name in node.attrsMap) { 31029 if (dirRE.test(name)) { 31030 var value = node.attrsMap[name]; 31031 if (value) { 31032 if (name === 'v-for') { 31033 checkFor(node, ("v-for=\"" + value + "\""), errors); 31034 } else if (onRE.test(name)) { 31035 checkEvent(value, (name + "=\"" + value + "\""), errors); 31036 } else { 31037 checkExpression(value, (name + "=\"" + value + "\""), errors); 31038 } 31039 } 31040 } 31041 } 31042 if (node.children) { 31043 for (var i = 0; i < node.children.length; i++) { 31044 checkNode(node.children[i], errors); 31045 } 31046 } 31047 } else if (node.type === 2) { 31048 checkExpression(node.expression, node.text, errors); 31049 } 31050} 31051 31052function checkEvent (exp, text, errors) { 31053 var stipped = exp.replace(stripStringRE, ''); 31054 var keywordMatch = stipped.match(unaryOperatorsRE); 31055 if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') { 31056 errors.push( 31057 "avoid using JavaScript unary operator as property name: " + 31058 "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()) 31059 ); 31060 } 31061 checkExpression(exp, text, errors); 31062} 31063 31064function checkFor (node, text, errors) { 31065 checkExpression(node.for || '', text, errors); 31066 checkIdentifier(node.alias, 'v-for alias', text, errors); 31067 checkIdentifier(node.iterator1, 'v-for iterator', text, errors); 31068 checkIdentifier(node.iterator2, 'v-for iterator', text, errors); 31069} 31070 31071function checkIdentifier ( 31072 ident, 31073 type, 31074 text, 31075 errors 31076) { 31077 if (typeof ident === 'string') { 31078 try { 31079 new Function(("var " + ident + "=_")); 31080 } catch (e) { 31081 errors.push(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim()))); 31082 } 31083 } 31084} 31085 31086function checkExpression (exp, text, errors) { 31087 try { 31088 new Function(("return " + exp)); 31089 } catch (e) { 31090 var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE); 31091 if (keywordMatch) { 31092 errors.push( 31093 "avoid using JavaScript keyword as property name: " + 31094 "\"" + (keywordMatch[0]) + "\"\n Raw expression: " + (text.trim()) 31095 ); 31096 } else { 31097 errors.push( 31098 "invalid expression: " + (e.message) + " in\n\n" + 31099 " " + exp + "\n\n" + 31100 " Raw expression: " + (text.trim()) + "\n" 31101 ); 31102 } 31103 } 31104} 31105 31106/* */ 31107 31108function createFunction (code, errors) { 31109 try { 31110 return new Function(code) 31111 } catch (err) { 31112 errors.push({ err: err, code: code }); 31113 return noop 31114 } 31115} 31116 31117function createCompileToFunctionFn (compile) { 31118 var cache = Object.create(null); 31119 31120 return function compileToFunctions ( 31121 template, 31122 options, 31123 vm 31124 ) { 31125 options = extend({}, options); 31126 var warn$$1 = options.warn || warn; 31127 delete options.warn; 31128 31129 /* istanbul ignore if */ 31130 { 31131 // detect possible CSP restriction
31132 try { 31133 new Function('return 1'); 31134 } catch (e) { 31135 if (e.toString().match(/unsafe-eval|CSP/)) { 31136 warn$$1( 31137 'It seems you are using the standalone build of Vue.js in an ' + 31138 'environment with Content Security Policy that prohibits unsafe-eval. ' + 31139 'The template compiler cannot work in this environment. Consider ' + 31140 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + 31141 'templates into render functions.' 31142 ); 31143 } 31144 } 31145 } 31146 31147 // check cache 31148 var key = options.delimiters 31149 ? String(options.delimiters) + template 31150 : template; 31151 if (cache[key]) { 31152 return cache[key] 31153 } 31154 31155 // compile 31156 var compiled = compile(template, options); 31157 31158 // check compilation errors/tips 31159 { 31160 if (compiled.errors && compiled.errors.length) { 31161 warn$$1( 31162 "Error compiling template:\n\n" + template + "\n\n" + 31163 compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n', 31164 vm 31165 ); 31166 } 31167 if (compiled.tips && compiled.tips.length) { 31168 compiled.tips.forEach(function (msg) { return tip(msg, vm); }); 31169 } 31170 } 31171 31172 // turn code into functions 31173 var res = {}; 31174 var fnGenErrors = []; 31175 res.render = createFunction(compiled.render, fnGenErrors); 31176 res.staticRenderFns = compiled.staticRenderFns.map(function (code) { 31177 return createFunction(code, fnGenErrors) 31178 }); 31179 31180 // check function generation errors. 31181 // this should only happen if there is a bug in the compiler itself. 31182 // mostly for codegen development use 31183 /* istanbul ignore if */ 31184 { 31185 if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) { 31186 warn$$1( 31187 "Failed to generate render function:\n\n" + 31188 fnGenErrors.map(function (ref) { 31189 var err = ref.err; 31190 var code = ref.code; 31191 31192 return ((err.toString()) + " in\n\n" + code + "\n"); 31193 }).join('\n'), 31194 vm 31195 ); 31196 } 31197 } 31198 31199 return (cache[key] = res) 31200 } 31201} 31202 31203/* */ 31204 31205function createCompilerCreator (baseCompile) { 31206 return function createCompiler (baseOptions) { 31207 function compile ( 31208 template, 31209 options 31210 ) { 31211 var finalOptions = Object.create(baseOptions); 31212 var errors = []; 31213 var tips = []; 31214 finalOptions.warn = function (msg, tip) { 31215 (tip ? tips : errors).push(msg); 31216 }; 31217 31218 if (options) { 31219 // merge custom modules 31220 if (options.modules) { 31221 finalOptions.modules = 31222 (baseOptions.modules || []).concat(options.modules); 31223 } 31224 // merge custom directives 31225 if (options.directives) { 31226 finalOptions.directives = extend( 31227 Object.create(baseOptions.directives), 31228 options.directives 31229 ); 31230 } 31231 // copy other options 31232 for (var key in options) { 31233 if (key !== 'modules' && key !== 'directives') { 31234 finalOptions[key] = options[key]; 31235 } 31236 } 31237 } 31238 31239 var compiled = baseCompile(template, finalOptions); 31240 { 31241 errors.push.apply(errors, detectErrors(compiled.ast)); 31242 } 31243 compiled.errors = errors; 31244 compiled.tips = tips; 31245 return compiled 31246 } 31247 31248 return { 31249 compile: compile, 31250 compileToFunctions: createCompileToFunctionFn(compile) 31251 } 31252 } 31253} 31254 31255/* */ 31256 31257// `createCompilerCreator` allows creating compilers that use alternative 31258// parser/optimizer/codegen, e.g the SSR optimizing compiler. 31259// Here we just export a default compiler using the default parts. 31260var createCompiler = createCompilerCreator(function baseCompile ( 31261 template, 31262 options 31263) { 31264 var ast = parse(template.trim(), options); 31265 optimize(ast, options); 31266 var code = generate(ast, options); 31267 return { 31268 ast: ast, 31269 render: code.render, 31270 staticRenderFns: code.staticRenderFns 31271 } 31272}); 31273 31274/* */ 31275 31276var ref$1 = createCompiler(baseOptions); 31277var compileToFunctions = ref$1.compileToFunctions; 31278 31279/* */ 31280 31281// check whether current browser encodes a char inside attribute values 31282var div; 31283function getShouldDecode (href) { 31284 div = div || document.createElement('div'); 31285 div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>"; 31286 return div.innerHTML.indexOf(' ') > 0 31287} 31288 31289// #3663: IE encodes newlines inside attribute values while other browsers don't 31290var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
31291// #6828: chrome encodes content in a[href] 31292var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false; 31293 31294/* */ 31295 31296var idToTemplate = cached(function (id) { 31297 var el = query(id); 31298 return el && el.innerHTML 31299}); 31300 31301var mount = Vue$3.prototype.$mount; 31302Vue$3.prototype.$mount = function ( 31303 el, 31304 hydrating 31305) { 31306 el = el && query(el); 31307 31308 /* istanbul ignore if */ 31309 if (el === document.body || el === document.documentElement) { 31310 "development" !== 'production' && warn( 31311 "Do not mount Vue to <html> or <body> - mount to normal elements instead." 31312 ); 31313 return this 31314 } 31315 31316 var options = this.$options; 31317 // resolve template/el and convert to render function 31318 if (!options.render) { 31319 var template = options.template; 31320 if (template) { 31321 if (typeof template === 'string') { 31322 if (template.charAt(0) === '#') { 31323 template = idToTemplate(template); 31324 /* istanbul ignore if */ 31325 if ("development" !== 'production' && !template) { 31326 warn( 31327 ("Template element not found or is empty: " + (options.template)), 31328 this 31329 ); 31330 } 31331 } 31332 } else if (template.nodeType) { 31333 template = template.innerHTML; 31334 } else { 31335 { 31336 warn('invalid template option:' + template, this); 31337 } 31338 return this 31339 } 31340 } else if (el) { 31341 template = getOuterHTML(el); 31342 } 31343 if (template) { 31344 /* istanbul ignore if */ 31345 if ("development" !== 'production' && config.performance && mark) { 31346 mark('compile'); 31347 } 31348 31349 var ref = compileToFunctions(template, { 31350 shouldDecodeNewlines: shouldDecodeNewlines, 31351 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, 31352 delimiters: options.delimiters, 31353 comments: options.comments 31354 }, this); 31355 var render = ref.render; 31356 var staticRenderFns = ref.staticRenderFns; 31357 options.render = render; 31358 options.staticRenderFns = staticRenderFns; 31359 31360 /* istanbul ignore if */ 31361 if ("development" !== 'production' && config.performance && mark) { 31362 mark('compile end'); 31363 measure(("vue " + (this._name) + " compile"), 'compile', 'compile end'); 31364 } 31365 } 31366 } 31367 return mount.call(this, el, hydrating) 31368}; 31369 31370/** 31371 * Get outerHTML of elements, taking care 31372 * of SVG elements in IE as well. 31373 */ 31374function getOuterHTML (el) { 31375 if (el.outerHTML) { 31376 return el.outerHTML 31377 } else { 31378 var container = document.createElement('div'); 31379 container.appendChild(el.cloneNode(true)); 31380 return container.innerHTML 31381 } 31382} 31383 31384Vue$3.compile = compileToFunctions; 31385 31386return Vue$3; 31387 31388}))); 31389 31390/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0), __webpack_require__(2).setImmediate)) 31391 31392/***/ }), 31393/* 38 */ 31394/***/ (function(module, exports, __webpack_require__) { 31395 31396__webpack_require__(4); 31397module.exports = __webpack_require__(5); 31398 31399 31400/***/ }) 31401/******/ ]);
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.