1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["/web/dist/js/vendor"],{ 2
vendor: 361 bytes, lines 3-13
3/***/ "./node_modules/axios/index.js": 4/*!*************************************!*\ 5 !*** ./node_modules/axios/index.js ***! 6 \*************************************/ 7/*! no static exports found */ 8/***/ (function(module, exports, __webpack_require__) { 9 10module.exports = __webpack_require__(/*! ./lib/axios */ "./node_modules/axios/lib/axios.js"); 11 12/***/ }), 13
vendor: 5,974 bytes, lines 14-187
14/***/ "./node_modules/axios/lib/adapters/xhr.js": 15/*!************************************************!*\ 16 !*** ./node_modules/axios/lib/adapters/xhr.js ***! 17 \************************************************/ 18/*! no static exports found */ 19/***/ (function(module, exports, __webpack_require__) { 20 21"use strict"; 22 23 24var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 25var settle = __webpack_require__(/*! ./../core/settle */ "./node_modules/axios/lib/core/settle.js"); 26var buildURL = __webpack_require__(/*! ./../helpers/buildURL */ "./node_modules/axios/lib/helpers/buildURL.js"); 27var parseHeaders = __webpack_require__(/*! ./../helpers/parseHeaders */ "./node_modules/axios/lib/helpers/parseHeaders.js"); 28var isURLSameOrigin = __webpack_require__(/*! ./../helpers/isURLSameOrigin */ "./node_modules/axios/lib/helpers/isURLSameOrigin.js"); 29var createError = __webpack_require__(/*! ../core/createError */ "./node_modules/axios/lib/core/createError.js"); 30 31module.exports = function xhrAdapter(config) { 32 return new Promise(function dispatchXhrRequest(resolve, reject) { 33 var requestData = config.data; 34 var requestHeaders = config.headers; 35 36 if (utils.isFormData(requestData)) { 37 delete requestHeaders['Content-Type']; // Let the browser set it 38 } 39 40 var request = new XMLHttpRequest(); 41 42 // HTTP basic authentication 43 if (config.auth) { 44 var username = config.auth.username || ''; 45 var password = config.auth.password || ''; 46 requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); 47 } 48 49 request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true); 50 51 // Set the request timeout in MS 52 request.timeout = config.timeout; 53 54 // Listen for ready state 55 request.onreadystatechange = function handleLoad() { 56 if (!request || request.readyState !== 4) { 57 return; 58 } 59 60 // The request errored out and we didn't get a response, this will be 61 // handled by onerror instead 62 // With one exception: request that using file: protocol, most browsers 63 // will return status as 0 even though it's a successful request 64 if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { 65 return; 66 } 67 68 // Prepare the response 69 var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; 70 var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response; 71 var response = { 72 data: responseData, 73 status: request.status, 74 statusText: request.statusText, 75 headers: responseHeaders, 76 config: config, 77 request: request 78 }; 79 80 settle(resolve, reject, response); 81 82 // Clean up request 83 request = null; 84 }; 85 86 // Handle low level network errors 87 request.onerror = function handleError() { 88 // Real errors are hidden from us by the browser 89 // onerror should only fire if it's a network error 90 reject(createError('Network Error', config, null, request)); 91 92 // Clean up request 93 request = null; 94 }; 95 96 // Handle timeout 97 request.ontimeout = function handleTimeout() { 98 reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED', 99 request)); 100 101 // Clean up request 102 request = null; 103 }; 104 105 // Add xsrf header 106 // This is only done if running in a standard browser environment. 107 // Specifically not if we're in a web worker, or react-native. 108 if (utils.isStandardBrowserEnv()) { 109 var cookies = __webpack_require__(/*! ./../helpers/cookies */ "./node_modules/axios/lib/helpers/cookies.js"); 110 111 // Add xsrf header 112 var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ? 113 cookies.read(config.xsrfCookieName) : 114 undefined; 115 116 if (xsrfValue) { 117 requestHeaders[config.xsrfHeaderName] = xsrfValue; 118 } 119 } 120 121 // Add headers to the request 122 if ('setRequestHeader' in request) { 123 utils.forEach(requestHeaders, function setRequestHeader(val, key) { 124 if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { 125 // Remove Content-Type if data is undefined 126 delete requestHeaders[key]; 127 } else { 128 // Otherwise add header to the request 129 request.setRequestHeader(key, val); 130 } 131 }); 132 } 133 134 // Add withCredentials to request if needed 135 if (config.withCredentials) { 136 request.withCredentials = true; 137 } 138 139 // Add responseType to request if needed 140 if (config.responseType) { 141 try { 142 request.responseType = config.responseType; 143 } catch (e) { 144 // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2. 145 // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function. 146 if (config.responseType !== 'json') { 147 throw e; 148 } 149 } 150 } 151 152 // Handle progress if needed 153 if (typeof config.onDownloadProgress === 'function') { 154 request.addEventListener('progress', config.onDownloadProgress); 155 } 156 157 // Not all browsers support upload events 158 if (typeof config.onUploadProgress === 'function' && request.upload) { 159 request.upload.addEventListener('progress', config.onUploadProgress); 160 } 161 162 if (config.cancelToken) { 163 // Handle cancellation 164 config.cancelToken.promise.then(function onCanceled(cancel) { 165 if (!request) { 166 return; 167 } 168 169 request.abort(); 170 reject(cancel); 171 // Clean up request 172 request = null; 173 }); 174 } 175 176 if (requestData === undefined) { 177 requestData = null; 178 } 179 180 // Send the request 181 request.send(requestData); 182 }); 183}; 184 185 186/***/ }), 187
vendor: 2,132 bytes, lines 188-251
188/***/ "./node_modules/axios/lib/axios.js": 189/*!*****************************************!*\ 190 !*** ./node_modules/axios/lib/axios.js ***! 191 \*****************************************/ 192/*! no static exports found */ 193/***/ (function(module, exports, __webpack_require__) { 194 195"use strict"; 196 197 198var utils = __webpack_require__(/*! ./utils */ "./node_modules/axios/lib/utils.js"); 199var bind = __webpack_require__(/*! ./helpers/bind */ "./node_modules/axios/lib/helpers/bind.js"); 200var Axios = __webpack_require__(/*! ./core/Axios */ "./node_modules/axios/lib/core/Axios.js"); 201var defaults = __webpack_require__(/*! ./defaults */ "./node_modules/axios/lib/defaults.js"); 202 203/** 204 * Create an instance of Axios 205 * 206 * @param {Object} defaultConfig The default config for the instance 207 * @return {Axios} A new instance of Axios 208 */ 209function createInstance(defaultConfig) { 210 var context = new Axios(defaultConfig); 211 var instance = bind(Axios.prototype.request, context); 212 213 // Copy axios.prototype to instance 214 utils.extend(instance, Axios.prototype, context); 215 216 // Copy context to instance 217 utils.extend(instance, context); 218 219 return instance; 220} 221 222// Create the default instance to be exported 223var axios = createInstance(defaults); 224 225// Expose Axios class to allow class inheritance 226axios.Axios = Axios; 227 228// Factory for creating new instances 229axios.create = function create(instanceConfig) { 230 return createInstance(utils.merge(defaults, instanceConfig)); 231}; 232 233// Expose Cancel & CancelToken 234axios.Cancel = __webpack_require__(/*! ./cancel/Cancel */ "./node_modules/axios/lib/cancel/Cancel.js"); 235axios.CancelToken = __webpack_require__(/*! ./cancel/CancelToken */ "./node_modules/axios/lib/cancel/CancelToken.js"); 236axios.isCancel = __webpack_require__(/*! ./cancel/isCancel */ "./node_modules/axios/lib/cancel/isCancel.js"); 237 238// Expose all/spread 239axios.all = function all(promises) { 240 return Promise.all(promises); 241}; 242axios.spread = __webpack_require__(/*! ./helpers/spread */ "./node_modules/axios/lib/helpers/spread.js"); 243 244module.exports = axios; 245 246// Allow use of default import syntax in TypeScript 247module.exports.default = axios; 248 249 250/***/ }), 251
vendor: 702 bytes, lines 252-282
252/***/ "./node_modules/axios/lib/cancel/Cancel.js": 253/*!*************************************************!*\ 254 !*** ./node_modules/axios/lib/cancel/Cancel.js ***! 255 \*************************************************/ 256/*! no static exports found */ 257/***/ (function(module, exports, __webpack_require__) { 258 259"use strict"; 260 261 262/** 263 * A `Cancel` is an object that is thrown when an operation is canceled. 264 * 265 * @class 266 * @param {string=} message The message. 267 */ 268function Cancel(message) { 269 this.message = message; 270} 271 272Cancel.prototype.toString = function toString() { 273 return 'Cancel' + (this.message ? ': ' + this.message : ''); 274}; 275 276Cancel.prototype.__CANCEL__ = true; 277 278module.exports = Cancel; 279 280 281/***/ }), 282
vendor: 1,638 bytes, lines 283-351
283/***/ "./node_modules/axios/lib/cancel/CancelToken.js": 284/*!******************************************************!*\ 285 !*** ./node_modules/axios/lib/cancel/CancelToken.js ***! 286 \******************************************************/ 287/*! no static exports found */ 288/***/ (function(module, exports, __webpack_require__) { 289 290"use strict"; 291 292 293var Cancel = __webpack_require__(/*! ./Cancel */ "./node_modules/axios/lib/cancel/Cancel.js"); 294 295/** 296 * A `CancelToken` is an object that can be used to request cancellation of an operation. 297 * 298 * @class 299 * @param {Function} executor The executor function. 300 */ 301function CancelToken(executor) { 302 if (typeof executor !== 'function') { 303 throw new TypeError('executor must be a function.'); 304 } 305 306 var resolvePromise; 307 this.promise = new Promise(function promiseExecutor(resolve) { 308 resolvePromise = resolve; 309 }); 310 311 var token = this; 312 executor(function cancel(message) { 313 if (token.reason) { 314 // Cancellation has already been requested 315 return; 316 } 317 318 token.reason = new Cancel(message); 319 resolvePromise(token.reason); 320 }); 321} 322 323/** 324 * Throws a `Cancel` if cancellation has been requested. 325 */ 326CancelToken.prototype.throwIfRequested = function throwIfRequested() { 327 if (this.reason) { 328 throw this.reason; 329 } 330}; 331 332/** 333 * Returns an object that contains a new `CancelToken` and a function that, when called, 334 * cancels the `CancelToken`. 335 */ 336CancelToken.source = function source() { 337 var cancel; 338 var token = new CancelToken(function executor(c) { 339 cancel = c; 340 }); 341 return { 342 token: token, 343 cancel: cancel 344 }; 345}; 346 347module.exports = CancelToken; 348 349 350/***/ }), 351
vendor: 427 bytes, lines 352-368
352/***/ "./node_modules/axios/lib/cancel/isCancel.js": 353/*!***************************************************!*\ 354 !*** ./node_modules/axios/lib/cancel/isCancel.js ***! 355 \***************************************************/ 356/*! no static exports found */ 357/***/ (function(module, exports, __webpack_require__) { 358 359"use strict"; 360 361 362module.exports = function isCancel(value) { 363 return !!(value && value.__CANCEL__); 364}; 365 366 367/***/ }), 368
vendor: 2,740 bytes, lines 369-459
369/***/ "./node_modules/axios/lib/core/Axios.js": 370/*!**********************************************!*\ 371 !*** ./node_modules/axios/lib/core/Axios.js ***! 372 \**********************************************/ 373/*! no static exports found */ 374/***/ (function(module, exports, __webpack_require__) { 375 376"use strict"; 377 378 379var defaults = __webpack_require__(/*! ./../defaults */ "./node_modules/axios/lib/defaults.js"); 380var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 381var InterceptorManager = __webpack_require__(/*! ./InterceptorManager */ "./node_modules/axios/lib/core/InterceptorManager.js"); 382var dispatchRequest = __webpack_require__(/*! ./dispatchRequest */ "./node_modules/axios/lib/core/dispatchRequest.js"); 383 384/** 385 * Create a new instance of Axios 386 * 387 * @param {Object} instanceConfig The default config for the instance 388 */ 389function Axios(instanceConfig) { 390 this.defaults = instanceConfig; 391 this.interceptors = { 392 request: new InterceptorManager(), 393 response: new InterceptorManager() 394 }; 395} 396 397/** 398 * Dispatch a request 399 * 400 * @param {Object} config The config specific for this request (merged with this.defaults) 401 */ 402Axios.prototype.request = function request(config) { 403 /*eslint no-param-reassign:0*/ 404 // Allow for axios('example/url'[, config]) a la fetch API 405 if (typeof config === 'string') { 406 config = utils.merge({ 407 url: arguments[0] 408 }, arguments[1]); 409 } 410 411 config = utils.merge(defaults, {method: 'get'}, this.defaults, config); 412 config.method = config.method.toLowerCase(); 413 414 // Hook up interceptors middleware 415 var chain = [dispatchRequest, undefined]; 416 var promise = Promise.resolve(config); 417 418 this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { 419 chain.unshift(interceptor.fulfilled, interceptor.rejected); 420 }); 421 422 this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { 423 chain.push(interceptor.fulfilled, interceptor.rejected); 424 }); 425 426 while (chain.length) { 427 promise = promise.then(chain.shift(), chain.shift()); 428 } 429 430 return promise; 431}; 432 433// Provide aliases for supported request methods 434utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) { 435 /*eslint func-names:0*/ 436 Axios.prototype[method] = function(url, config) { 437 return this.request(utils.merge(config || {}, { 438 method: method, 439 url: url 440 })); 441 }; 442}); 443 444utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 445 /*eslint func-names:0*/ 446 Axios.prototype[method] = function(url, data, config) { 447 return this.request(utils.merge(config || {}, { 448 method: method, 449 url: url, 450 data: data 451 })); 452 }; 453}); 454 455module.exports = Axios; 456 457 458/***/ }), 459
vendor: 1,661 bytes, lines 460-523
460/***/ "./node_modules/axios/lib/core/InterceptorManager.js": 461/*!***********************************************************!*\ 462 !*** ./node_modules/axios/lib/core/InterceptorManager.js ***! 463 \***********************************************************/ 464/*! no static exports found */ 465/***/ (function(module, exports, __webpack_require__) { 466 467"use strict"; 468 469 470var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 471 472function InterceptorManager() { 473 this.handlers = []; 474} 475 476/** 477 * Add a new interceptor to the stack 478 * 479 * @param {Function} fulfilled The function to handle `then` for a `Promise` 480 * @param {Function} rejected The function to handle `reject` for a `Promise` 481 * 482 * @return {Number} An ID used to remove interceptor later 483 */ 484InterceptorManager.prototype.use = function use(fulfilled, rejected) { 485 this.handlers.push({ 486 fulfilled: fulfilled, 487 rejected: rejected 488 }); 489 return this.handlers.length - 1; 490}; 491 492/** 493 * Remove an interceptor from the stack 494 * 495 * @param {Number} id The ID that was returned by `use` 496 */ 497InterceptorManager.prototype.eject = function eject(id) { 498 if (this.handlers[id]) { 499 this.handlers[id] = null; 500 } 501}; 502 503/** 504 * Iterate over all the registered interceptors 505 * 506 * This method is particularly useful for skipping over any 507 * interceptors that may have become `null` calling `eject`. 508 * 509 * @param {Function} fn The function to call for each interceptor 510 */ 511InterceptorManager.prototype.forEach = function forEach(fn) { 512 utils.forEach(this.handlers, function forEachHandler(h) { 513 if (h !== null) { 514 fn(h); 515 } 516 }); 517}; 518 519module.exports = InterceptorManager; 520 521 522/***/ }), 523
vendor: 1,019 bytes, lines 524-553
524/***/ "./node_modules/axios/lib/core/createError.js": 525/*!****************************************************!*\ 526 !*** ./node_modules/axios/lib/core/createError.js ***! 527 \****************************************************/ 528/*! no static exports found */ 529/***/ (function(module, exports, __webpack_require__) { 530 531"use strict"; 532 533 534var enhanceError = __webpack_require__(/*! ./enhanceError */ "./node_modules/axios/lib/core/enhanceError.js"); 535 536/** 537 * Create an Error with the specified message, config, error code, request and response. 538 * 539 * @param {string} message The error message. 540 * @param {Object} config The config. 541 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 542 * @param {Object} [request] The request. 543 * @param {Object} [response] The response. 544 * @returns {Error} The created error. 545 */ 546module.exports = function createError(message, config, code, request, response) { 547 var error = new Error(message); 548 return enhanceError(error, config, code, request, response); 549}; 550 551 552/***/ }), 553
vendor: 2,918 bytes, lines 554-651
554/***/ "./node_modules/axios/lib/core/dispatchRequest.js": 555/*!********************************************************!*\ 556 !*** ./node_modules/axios/lib/core/dispatchRequest.js ***! 557 \********************************************************/ 558/*! no static exports found */ 559/***/ (function(module, exports, __webpack_require__) { 560 561"use strict"; 562 563 564var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 565var transformData = __webpack_require__(/*! ./transformData */ "./node_modules/axios/lib/core/transformData.js"); 566var isCancel = __webpack_require__(/*! ../cancel/isCancel */ "./node_modules/axios/lib/cancel/isCancel.js"); 567var defaults = __webpack_require__(/*! ../defaults */ "./node_modules/axios/lib/defaults.js"); 568var isAbsoluteURL = __webpack_require__(/*! ./../helpers/isAbsoluteURL */ "./node_modules/axios/lib/helpers/isAbsoluteURL.js"); 569var combineURLs = __webpack_require__(/*! ./../helpers/combineURLs */ "./node_modules/axios/lib/helpers/combineURLs.js"); 570 571/** 572 * Throws a `Cancel` if cancellation has been requested. 573 */ 574function throwIfCancellationRequested(config) { 575 if (config.cancelToken) { 576 config.cancelToken.throwIfRequested(); 577 } 578} 579 580/** 581 * Dispatch a request to the server using the configured adapter. 582 * 583 * @param {object} config The config that is to be used for the request 584 * @returns {Promise} The Promise to be fulfilled 585 */ 586module.exports = function dispatchRequest(config) { 587 throwIfCancellationRequested(config); 588 589 // Support baseURL config 590 if (config.baseURL && !isAbsoluteURL(config.url)) { 591 config.url = combineURLs(config.baseURL, config.url); 592 } 593 594 // Ensure headers exist 595 config.headers = config.headers || {}; 596 597 // Transform request data 598 config.data = transformData( 599 config.data, 600 config.headers, 601 config.transformRequest 602 ); 603 604 // Flatten headers 605 config.headers = utils.merge( 606 config.headers.common || {}, 607 config.headers[config.method] || {}, 608 config.headers || {} 609 ); 610 611 utils.forEach( 612 ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], 613 function cleanHeaderConfig(method) { 614 delete config.headers[method]; 615 } 616 ); 617 618 var adapter = config.adapter || defaults.adapter; 619 620 return adapter(config).then(function onAdapterResolution(response) { 621 throwIfCancellationRequested(config); 622 623 // Transform response data 624 response.data = transformData( 625 response.data, 626 response.headers, 627 config.transformResponse 628 ); 629 630 return response; 631 }, function onAdapterRejection(reason) { 632 if (!isCancel(reason)) { 633 throwIfCancellationRequested(config); 634 635 // Transform response data 636 if (reason && reason.response) { 637 reason.response.data = transformData( 638 reason.response.data, 639 reason.response.headers, 640 config.transformResponse 641 ); 642 } 643 } 644 645 return Promise.reject(reason); 646 }); 647}; 648 649 650/***/ }), 651
vendor: 925 bytes, lines 652-684
652/***/ "./node_modules/axios/lib/core/enhanceError.js": 653/*!*****************************************************!*\ 654 !*** ./node_modules/axios/lib/core/enhanceError.js ***! 655 \*****************************************************/ 656/*! no static exports found */ 657/***/ (function(module, exports, __webpack_require__) { 658 659"use strict"; 660 661 662/** 663 * Update an Error with the specified config, error code, and response. 664 * 665 * @param {Error} error The error to update. 666 * @param {Object} config The config. 667 * @param {string} [code] The error code (for example, 'ECONNABORTED'). 668 * @param {Object} [request] The request. 669 * @param {Object} [response] The response. 670 * @returns {Error} The error. 671 */ 672module.exports = function enhanceError(error, config, code, request, response) { 673 error.config = config; 674 if (code) { 675 error.code = code; 676 } 677 error.request = request; 678 error.response = response; 679 return error; 680}; 681 682 683/***/ }), 684
vendor: 1,130 bytes, lines 685-722
685/***/ "./node_modules/axios/lib/core/settle.js": 686/*!***********************************************!*\ 687 !*** ./node_modules/axios/lib/core/settle.js ***! 688 \***********************************************/ 689/*! no static exports found */ 690/***/ (function(module, exports, __webpack_require__) { 691 692"use strict"; 693 694 695var createError = __webpack_require__(/*! ./createError */ "./node_modules/axios/lib/core/createError.js"); 696 697/** 698 * Resolve or reject a Promise based on response status. 699 * 700 * @param {Function} resolve A function that resolves the promise. 701 * @param {Function} reject A function that rejects the promise. 702 * @param {object} response The response. 703 */ 704module.exports = function settle(resolve, reject, response) { 705 var validateStatus = response.config.validateStatus; 706 // Note: status is not exposed by XDomainRequest 707 if (!response.status || !validateStatus || validateStatus(response.status)) { 708 resolve(response); 709 } else { 710 reject(createError( 711 'Request failed with status code ' + response.status, 712 response.config, 713 null, 714 response.request, 715 response 716 )); 717 } 718}; 719 720 721/***/ }), 722
vendor: 940 bytes, lines 723-754
723/***/ "./node_modules/axios/lib/core/transformData.js": 724/*!******************************************************!*\ 725 !*** ./node_modules/axios/lib/core/transformData.js ***! 726 \******************************************************/ 727/*! no static exports found */ 728/***/ (function(module, exports, __webpack_require__) { 729 730"use strict"; 731 732 733var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 734 735/** 736 * Transform the data for a request or a response 737 * 738 * @param {Object|String} data The data to be transformed 739 * @param {Array} headers The headers for the request or response 740 * @param {Array|Function} fns A single function or Array of functions 741 * @returns {*} The resulting transformed data 742 */ 743module.exports = function transformData(data, headers, fns) { 744 /*eslint no-param-reassign:0*/ 745 utils.forEach(fns, function transform(fn) { 746 data = fn(data, headers); 747 }); 748 749 return data; 750}; 751 752 753/***/ }), 754
vendor: 3,157 bytes, lines 755-863
755/***/ "./node_modules/axios/lib/defaults.js": 756/*!********************************************!*\ 757 !*** ./node_modules/axios/lib/defaults.js ***! 758 \********************************************/ 759/*! no static exports found */ 760/***/ (function(module, exports, __webpack_require__) { 761 762"use strict"; 763/* WEBPACK VAR INJECTION */(function(process) { 764 765var utils = __webpack_require__(/*! ./utils */ "./node_modules/axios/lib/utils.js"); 766var normalizeHeaderName = __webpack_require__(/*! ./helpers/normalizeHeaderName */ "./node_modules/axios/lib/helpers/normalizeHeaderName.js"); 767 768var DEFAULT_CONTENT_TYPE = { 769 'Content-Type': 'application/x-www-form-urlencoded' 770}; 771 772function setContentTypeIfUnset(headers, value) { 773 if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { 774 headers['Content-Type'] = value; 775 } 776} 777 778function getDefaultAdapter() { 779 var adapter; 780 if (typeof XMLHttpRequest !== 'undefined') { 781 // For browsers use XHR adapter 782 adapter = __webpack_require__(/*! ./adapters/xhr */ "./node_modules/axios/lib/adapters/xhr.js"); 783 } else if (typeof process !== 'undefined') { 784 // For node use HTTP adapter 785 adapter = __webpack_require__(/*! ./adapters/http */ "./node_modules/axios/lib/adapters/xhr.js"); 786 } 787 return adapter; 788} 789 790var defaults = { 791 adapter: getDefaultAdapter(), 792 793 transformRequest: [function transformRequest(data, headers) { 794 normalizeHeaderName(headers, 'Content-Type'); 795 if (utils.isFormData(data) || 796 utils.isArrayBuffer(data) || 797 utils.isBuffer(data) || 798 utils.isStream(data) || 799 utils.isFile(data) || 800 utils.isBlob(data) 801 ) { 802 return data; 803 } 804 if (utils.isArrayBufferView(data)) { 805 return data.buffer; 806 } 807 if (utils.isURLSearchParams(data)) { 808 setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); 809 return data.toString(); 810 } 811 if (utils.isObject(data)) { 812 setContentTypeIfUnset(headers, 'application/json;charset=utf-8'); 813 return JSON.stringify(data); 814 } 815 return data; 816 }], 817 818 transformResponse: [function transformResponse(data) { 819 /*eslint no-param-reassign:0*/ 820 if (typeof data === 'string') { 821 try { 822 data = JSON.parse(data); 823 } catch (e) { /* Ignore */ } 824 } 825 return data; 826 }], 827 828 /** 829 * A timeout in milliseconds to abort a request. If set to 0 (default) a 830 * timeout is not created. 831 */ 832 timeout: 0, 833 834 xsrfCookieName: 'XSRF-TOKEN', 835 xsrfHeaderName: 'X-XSRF-TOKEN', 836 837 maxContentLength: -1, 838 839 validateStatus: function validateStatus(status) { 840 return status >= 200 && status < 300; 841 } 842}; 843 844defaults.headers = { 845 common: { 846 'Accept': 'application/json, text/plain, */*' 847 } 848}; 849 850utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { 851 defaults.headers[method] = {}; 852}); 853 854utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { 855 defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); 856}); 857 858module.exports = defaults; 859 860/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js"))) 861 862/***/ }), 863
vendor: 569 bytes, lines 864-886
864/***/ "./node_modules/axios/lib/helpers/bind.js": 865/*!************************************************!*\ 866 !*** ./node_modules/axios/lib/helpers/bind.js ***! 867 \************************************************/ 868/*! no static exports found */ 869/***/ (function(module, exports, __webpack_require__) { 870 871"use strict"; 872 873 874module.exports = function bind(fn, thisArg) { 875 return function wrap() { 876 var args = new Array(arguments.length); 877 for (var i = 0; i < args.length; i++) { 878 args[i] = arguments[i]; 879 } 880 return fn.apply(thisArg, args); 881 }; 882}; 883 884 885/***/ }), 886
vendor: 1,931 bytes, lines 887-964
887/***/ "./node_modules/axios/lib/helpers/buildURL.js": 888/*!****************************************************!*\ 889 !*** ./node_modules/axios/lib/helpers/buildURL.js ***! 890 \****************************************************/ 891/*! no static exports found */ 892/***/ (function(module, exports, __webpack_require__) { 893 894"use strict"; 895 896 897var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 898 899function encode(val) { 900 return encodeURIComponent(val). 901 replace(/%40/gi, '@'). 902 replace(/%3A/gi, ':'). 903 replace(/%24/g, '$'). 904 replace(/%2C/gi, ','). 905 replace(/%20/g, '+'). 906 replace(/%5B/gi, '['). 907 replace(/%5D/gi, ']'); 908} 909 910/** 911 * Build a URL by appending params to the end 912 * 913 * @param {string} url The base of the url (e.g., http://www.google.com) 914 * @param {object} [params] The params to be appended 915 * @returns {string} The formatted url 916 */ 917module.exports = function buildURL(url, params, paramsSerializer) { 918 /*eslint no-param-reassign:0*/ 919 if (!params) { 920 return url; 921 } 922 923 var serializedParams; 924 if (paramsSerializer) { 925 serializedParams = paramsSerializer(params); 926 } else if (utils.isURLSearchParams(params)) { 927 serializedParams = params.toString(); 928 } else { 929 var parts = []; 930 931 utils.forEach(params, function serialize(val, key) { 932 if (val === null || typeof val === 'undefined') { 933 return; 934 } 935 936 if (utils.isArray(val)) { 937 key = key + '[]'; 938 } else { 939 val = [val]; 940 } 941 942 utils.forEach(val, function parseValue(v) { 943 if (utils.isDate(v)) { 944 v = v.toISOString(); 945 } else if (utils.isObject(v)) { 946 v = JSON.stringify(v); 947 } 948 parts.push(encode(key) + '=' + encode(v)); 949 }); 950 }); 951 952 serializedParams = parts.join('&'); 953 } 954 955 if (serializedParams) { 956 url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; 957 } 958 959 return url; 960}; 961 962 963/***/ }), 964
vendor: 721 bytes, lines 965-990
965/***/ "./node_modules/axios/lib/helpers/combineURLs.js": 966/*!*******************************************************!*\ 967 !*** ./node_modules/axios/lib/helpers/combineURLs.js ***! 968 \*******************************************************/ 969/*! no static exports found */ 970/***/ (function(module, exports, __webpack_require__) { 971 972"use strict"; 973 974 975/** 976 * Creates a new URL by combining the specified URLs 977 * 978 * @param {string} baseURL The base URL 979 * @param {string} relativeURL The relative URL 980 * @returns {string} The combined URL 981 */ 982module.exports = function combineURLs(baseURL, relativeURL) { 983 return relativeURL 984 ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') 985 : baseURL; 986}; 987 988 989/***/ }), 990
vendor: 1,743 bytes, lines 991-1055
991/***/ "./node_modules/axios/lib/helpers/cookies.js": 992/*!***************************************************!*\ 993 !*** ./node_modules/axios/lib/helpers/cookies.js ***! 994 \***************************************************/ 995/*! no static exports found */ 996/***/ (function(module, exports, __webpack_require__) { 997 998"use strict"; 999 1000 1001var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 1002 1003module.exports = ( 1004 utils.isStandardBrowserEnv() ? 1005 1006 // Standard browser envs support document.cookie 1007 (function standardBrowserEnv() { 1008 return { 1009 write: function write(name, value, expires, path, domain, secure) { 1010 var cookie = []; 1011 cookie.push(name + '=' + encodeURIComponent(value)); 1012 1013 if (utils.isNumber(expires)) { 1014 cookie.push('expires=' + new Date(expires).toGMTString()); 1015 } 1016 1017 if (utils.isString(path)) { 1018 cookie.push('path=' + path); 1019 } 1020 1021 if (utils.isString(domain)) { 1022 cookie.push('domain=' + domain); 1023 } 1024 1025 if (secure === true) { 1026 cookie.push('secure'); 1027 } 1028 1029 document.cookie = cookie.join('; '); 1030 }, 1031 1032 read: function read(name) { 1033 var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); 1034 return (match ? decodeURIComponent(match[3]) : null); 1035 }, 1036 1037 remove: function remove(name) { 1038 this.write(name, '', Date.now() - 86400000); 1039 } 1040 }; 1041 })() : 1042 1043 // Non standard browser env (web workers, react-native) lack needed support. 1044 (function nonStandardBrowserEnv() { 1045 return { 1046 write: function write() {}, 1047 read: function read() { return null; }, 1048 remove: function remove() {} 1049 }; 1050 })() 1051); 1052 1053 1054/***/ }), 1055
vendor: 912 bytes, lines 1056-1081
1056/***/ "./node_modules/axios/lib/helpers/isAbsoluteURL.js": 1057/*!*********************************************************!*\ 1058 !*** ./node_modules/axios/lib/helpers/isAbsoluteURL.js ***! 1059 \*********************************************************/ 1060/*! no static exports found */ 1061/***/ (function(module, exports, __webpack_require__) { 1062 1063"use strict"; 1064 1065 1066/** 1067 * Determines whether the specified URL is absolute 1068 * 1069 * @param {string} url The URL to test 1070 * @returns {boolean} True if the specified URL is absolute, otherwise false 1071 */ 1072module.exports = function isAbsoluteURL(url) { 1073 // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL). 1074 // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed 1075 // by any combination of letters, digits, plus, period, or hyphen. 1076 return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); 1077}; 1078 1079 1080/***/ }), 1081
vendor: 2,655 bytes, lines 1082-1161
1082/***/ "./node_modules/axios/lib/helpers/isURLSameOrigin.js": 1083/*!***********************************************************!*\ 1084 !*** ./node_modules/axios/lib/helpers/isURLSameOrigin.js ***! 1085 \***********************************************************/ 1086/*! no static exports found */ 1087/***/ (function(module, exports, __webpack_require__) { 1088 1089"use strict"; 1090 1091 1092var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 1093 1094module.exports = ( 1095 utils.isStandardBrowserEnv() ? 1096 1097 // Standard browser envs have full support of the APIs needed to test 1098 // whether the request URL is of the same origin as current location. 1099 (function standardBrowserEnv() { 1100 var msie = /(msie|trident)/i.test(navigator.userAgent); 1101 var urlParsingNode = document.createElement('a'); 1102 var originURL; 1103 1104 /** 1105 * Parse a URL to discover it's components 1106 * 1107 * @param {String} url The URL to be parsed 1108 * @returns {Object} 1109 */ 1110 function resolveURL(url) { 1111 var href = url; 1112 1113 if (msie) { 1114 // IE needs attribute set twice to normalize properties 1115 urlParsingNode.setAttribute('href', href); 1116 href = urlParsingNode.href; 1117 } 1118 1119 urlParsingNode.setAttribute('href', href); 1120 1121 // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils 1122 return { 1123 href: urlParsingNode.href, 1124 protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', 1125 host: urlParsingNode.host, 1126 search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', 1127 hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', 1128 hostname: urlParsingNode.hostname, 1129 port: urlParsingNode.port, 1130 pathname: (urlParsingNode.pathname.charAt(0) === '/') ? 1131 urlParsingNode.pathname : 1132 '/' + urlParsingNode.pathname 1133 }; 1134 } 1135 1136 originURL = resolveURL(window.location.href); 1137 1138 /** 1139 * Determine if a URL shares the same origin as the current location 1140 * 1141 * @param {String} requestURL The URL to test 1142 * @returns {boolean} True if URL shares the same origin, otherwise false 1143 */ 1144 return function isURLSameOrigin(requestURL) { 1145 var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; 1146 return (parsed.protocol === originURL.protocol && 1147 parsed.host === originURL.host); 1148 }; 1149 })() : 1150 1151 // Non standard browser envs (web workers, react-native) lack needed support. 1152 (function nonStandardBrowserEnv() { 1153 return function isURLSameOrigin() { 1154 return true; 1155 }; 1156 })() 1157); 1158 1159 1160/***/ }), 1161
vendor: 783 bytes, lines 1162-1185
1162/***/ "./node_modules/axios/lib/helpers/normalizeHeaderName.js": 1163/*!***************************************************************!*\ 1164 !*** ./node_modules/axios/lib/helpers/normalizeHeaderName.js ***! 1165 \***************************************************************/ 1166/*! no static exports found */ 1167/***/ (function(module, exports, __webpack_require__) { 1168 1169"use strict"; 1170 1171 1172var utils = __webpack_require__(/*! ../utils */ "./node_modules/axios/lib/utils.js"); 1173 1174module.exports = function normalizeHeaderName(headers, normalizedName) { 1175 utils.forEach(headers, function processHeader(value, name) { 1176 if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { 1177 headers[normalizedName] = value; 1178 delete headers[name]; 1179 } 1180 }); 1181}; 1182 1183 1184/***/ }), 1185
vendor: 1,791 bytes, lines 1186-1250
1186/***/ "./node_modules/axios/lib/helpers/parseHeaders.js": 1187/*!********************************************************!*\ 1188 !*** ./node_modules/axios/lib/helpers/parseHeaders.js ***! 1189 \********************************************************/ 1190/*! no static exports found */ 1191/***/ (function(module, exports, __webpack_require__) { 1192 1193"use strict"; 1194 1195 1196var utils = __webpack_require__(/*! ./../utils */ "./node_modules/axios/lib/utils.js"); 1197 1198// Headers whose duplicates are ignored by node 1199// c.f. https://nodejs.org/api/http.html#http_message_headers 1200var ignoreDuplicateOf = [ 1201 'age', 'authorization', 'content-length', 'content-type', 'etag', 1202 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 1203 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 1204 'referer', 'retry-after', 'user-agent' 1205]; 1206 1207/** 1208 * Parse headers into an object 1209 * 1210 * ``` 1211 * Date: Wed, 27 Aug 2014 08:58:49 GMT 1212 * Content-Type: application/json 1213 * Connection: keep-alive 1214 * Transfer-Encoding: chunked 1215 * ``` 1216 * 1217 * @param {String} headers Headers needing to be parsed 1218 * @returns {Object} Headers parsed into an object 1219 */ 1220module.exports = function parseHeaders(headers) { 1221 var parsed = {}; 1222 var key; 1223 var val; 1224 var i; 1225 1226 if (!headers) { return parsed; } 1227 1228 utils.forEach(headers.split('\n'), function parser(line) { 1229 i = line.indexOf(':'); 1230 key = utils.trim(line.substr(0, i)).toLowerCase(); 1231 val = utils.trim(line.substr(i + 1)); 1232 1233 if (key) { 1234 if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { 1235 return; 1236 } 1237 if (key === 'set-cookie') { 1238 parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]); 1239 } else { 1240 parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; 1241 } 1242 } 1243 }); 1244 1245 return parsed; 1246}; 1247 1248 1249/***/ }), 1250
vendor: 885 bytes, lines 1251-1289
1251/***/ "./node_modules/axios/lib/helpers/spread.js": 1252/*!**************************************************!*\ 1253 !*** ./node_modules/axios/lib/helpers/spread.js ***! 1254 \**************************************************/ 1255/*! no static exports found */ 1256/***/ (function(module, exports, __webpack_require__) { 1257 1258"use strict"; 1259 1260 1261/** 1262 * Syntactic sugar for invoking a function and expanding an array for arguments. 1263 * 1264 * Common use case would be to use `Function.prototype.apply`. 1265 * 1266 * ```js 1267 * function f(x, y, z) {} 1268 * var args = [1, 2, 3]; 1269 * f.apply(null, args); 1270 * ``` 1271 * 1272 * With `spread` this example can be re-written. 1273 * 1274 * ```js 1275 * spread(function(x, y, z) {})([1, 2, 3]); 1276 * ``` 1277 * 1278 * @param {Function} callback 1279 * @returns {Function} 1280 */ 1281module.exports = function spread(callback) { 1282 return function wrap(arr) { 1283 return callback.apply(null, arr); 1284 }; 1285}; 1286 1287 1288/***/ }), 1289
vendor: 7,939 bytes, lines 1290-1604
1290/***/ "./node_modules/axios/lib/utils.js": 1291/*!*****************************************!*\ 1292 !*** ./node_modules/axios/lib/utils.js ***! 1293 \*****************************************/ 1294/*! no static exports found */ 1295/***/ (function(module, exports, __webpack_require__) { 1296 1297"use strict"; 1298 1299 1300var bind = __webpack_require__(/*! ./helpers/bind */ "./node_modules/axios/lib/helpers/bind.js"); 1301var isBuffer = __webpack_require__(/*! is-buffer */ "./node_modules/is-buffer/index.js"); 1302 1303/*global toString:true*/ 1304 1305// utils is a library of generic helper functions non-specific to axios 1306 1307var toString = Object.prototype.toString; 1308 1309/** 1310 * Determine if a value is an Array 1311 * 1312 * @param {Object} val The value to test 1313 * @returns {boolean} True if value is an Array, otherwise false 1314 */ 1315function isArray(val) { 1316 return toString.call(val) === '[object Array]'; 1317} 1318 1319/** 1320 * Determine if a value is an ArrayBuffer 1321 * 1322 * @param {Object} val The value to test 1323 * @returns {boolean} True if value is an ArrayBuffer, otherwise false 1324 */ 1325function isArrayBuffer(val) { 1326 return toString.call(val) === '[object ArrayBuffer]'; 1327} 1328 1329/** 1330 * Determine if a value is a FormData 1331 * 1332 * @param {Object} val The value to test 1333 * @returns {boolean} True if value is an FormData, otherwise false 1334 */ 1335function isFormData(val) { 1336 return (typeof FormData !== 'undefined') && (val instanceof FormData); 1337} 1338 1339/** 1340 * Determine if a value is a view on an ArrayBuffer 1341 * 1342 * @param {Object} val The value to test 1343 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false 1344 */ 1345function isArrayBufferView(val) { 1346 var result; 1347 if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { 1348 result = ArrayBuffer.isView(val); 1349 } else { 1350 result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer); 1351 } 1352 return result; 1353} 1354 1355/** 1356 * Determine if a value is a String 1357 * 1358 * @param {Object} val The value to test 1359 * @returns {boolean} True if value is a String, otherwise false 1360 */ 1361function isString(val) { 1362 return typeof val === 'string'; 1363} 1364 1365/** 1366 * Determine if a value is a Number 1367 * 1368 * @param {Object} val The value to test 1369 * @returns {boolean} True if value is a Number, otherwise false 1370 */ 1371function isNumber(val) { 1372 return typeof val === 'number'; 1373} 1374 1375/** 1376 * Determine if a value is undefined 1377 * 1378 * @param {Object} val The value to test 1379 * @returns {boolean} True if the value is undefined, otherwise false 1380 */ 1381function isUndefined(val) { 1382 return typeof val === 'undefined'; 1383} 1384 1385/** 1386 * Determine if a value is an Object 1387 * 1388 * @param {Object} val The value to test 1389 * @returns {boolean} True if value is an Object, otherwise false 1390 */ 1391function isObject(val) { 1392 return val !== null && typeof val === 'object'; 1393} 1394 1395/** 1396 * Determine if a value is a Date 1397 * 1398 * @param {Object} val The value to test 1399 * @returns {boolean} True if value is a Date, otherwise false 1400 */ 1401function isDate(val) { 1402 return toString.call(val) === '[object Date]'; 1403} 1404 1405/** 1406 * Determine if a value is a File 1407 * 1408 * @param {Object} val The value to test 1409 * @returns {boolean} True if value is a File, otherwise false 1410 */ 1411function isFile(val) { 1412 return toString.call(val) === '[object File]'; 1413} 1414 1415/** 1416 * Determine if a value is a Blob 1417 * 1418 * @param {Object} val The value to test 1419 * @returns {boolean} True if value is a Blob, otherwise false 1420 */ 1421function isBlob(val) { 1422 return toString.call(val) === '[object Blob]'; 1423} 1424 1425/** 1426 * Determine if a value is a Function 1427 * 1428 * @param {Object} val The value to test 1429 * @returns {boolean} True if value is a Function, otherwise false 1430 */ 1431function isFunction(val) { 1432 return toString.call(val) === '[object Function]'; 1433} 1434 1435/** 1436 * Determine if a value is a Stream 1437 * 1438 * @param {Object} val The value to test 1439 * @returns {boolean} True if value is a Stream, otherwise false 1440 */ 1441function isStream(val) { 1442 return isObject(val) && isFunction(val.pipe); 1443} 1444 1445/** 1446 * Determine if a value is a URLSearchParams object 1447 * 1448 * @param {Object} val The value to test 1449 * @returns {boolean} True if value is a URLSearchParams object, otherwise false 1450 */ 1451function isURLSearchParams(val) { 1452 return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams; 1453} 1454 1455/** 1456 * Trim excess whitespace off the beginning and end of a string 1457 * 1458 * @param {String} str The String to trim 1459 * @returns {String} The String freed of excess whitespace 1460 */ 1461function trim(str) { 1462 return str.replace(/^\s*/, '').replace(/\s*$/, ''); 1463} 1464 1465/** 1466 * Determine if we're running in a standard browser environment 1467 * 1468 * This allows axios to run in a web worker, and react-native. 1469 * Both environments support XMLHttpRequest, but not fully standard globals. 1470 * 1471 * web workers: 1472 * typeof window -> undefined 1473 * typeof document -> undefined 1474 * 1475 * react-native: 1476 * navigator.product -> 'ReactNative' 1477 */ 1478function isStandardBrowserEnv() { 1479 if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') { 1480 return false; 1481 } 1482 return ( 1483 typeof window !== 'undefined' && 1484 typeof document !== 'undefined' 1485 ); 1486} 1487 1488/** 1489 * Iterate over an Array or an Object invoking a function for each item. 1490 * 1491 * If `obj` is an Array callback will be called passing 1492 * the value, index, and complete array for each item. 1493 * 1494 * If 'obj' is an Object callback will be called passing 1495 * the value, key, and complete object for each property. 1496 * 1497 * @param {Object|Array} obj The object to iterate 1498 * @param {Function} fn The callback to invoke for each item 1499 */ 1500function forEach(obj, fn) { 1501 // Don't bother if no value provided 1502 if (obj === null || typeof obj === 'undefined') { 1503 return; 1504 } 1505 1506 // Force an array if not already something iterable 1507 if (typeof obj !== 'object') { 1508 /*eslint no-param-reassign:0*/ 1509 obj = [obj]; 1510 } 1511 1512 if (isArray(obj)) { 1513 // Iterate over array values 1514 for (var i = 0, l = obj.length; i < l; i++) { 1515 fn.call(null, obj[i], i, obj); 1516 } 1517 } else { 1518 // Iterate over object keys 1519 for (var key in obj) { 1520 if (Object.prototype.hasOwnProperty.call(obj, key)) { 1521 fn.call(null, obj[key], key, obj); 1522 } 1523 } 1524 } 1525} 1526 1527/** 1528 * Accepts varargs expecting each argument to be an object, then 1529 * immutably merges the properties of each object and returns result. 1530 * 1531 * When multiple objects contain the same key the later object in 1532 * the arguments list will take precedence. 1533 * 1534 * Example: 1535 * 1536 * ```js 1537 * var result = merge({foo: 123}, {foo: 456}); 1538 * console.log(result.foo); // outputs 456 1539 * ``` 1540 * 1541 * @param {Object} obj1 Object to merge 1542 * @returns {Object} Result of all merge properties 1543 */ 1544function merge(/* obj1, obj2, obj3, ... */) { 1545 var result = {}; 1546 function assignValue(val, key) { 1547 if (typeof result[key] === 'object' && typeof val === 'object') { 1548 result[key] = merge(result[key], val); 1549 } else { 1550 result[key] = val; 1551 } 1552 } 1553 1554 for (var i = 0, l = arguments.length; i < l; i++) { 1555 forEach(arguments[i], assignValue); 1556 } 1557 return result; 1558} 1559 1560/** 1561 * Extends object a by mutably adding to it the properties of object b. 1562 * 1563 * @param {Object} a The object to be extended 1564 * @param {Object} b The object to copy properties from 1565 * @param {Object} thisArg The object to bind function to 1566 * @return {Object} The resulting value of object a 1567 */ 1568function extend(a, b, thisArg) { 1569 forEach(b, function assignValue(val, key) { 1570 if (thisArg && typeof val === 'function') { 1571 a[key] = bind(val, thisArg); 1572 } else { 1573 a[key] = val; 1574 } 1575 }); 1576 return a; 1577} 1578 1579module.exports = { 1580 isArray: isArray, 1581 isArrayBuffer: isArrayBuffer, 1582 isBuffer: isBuffer, 1583 isFormData: isFormData, 1584 isArrayBufferView: isArrayBufferView, 1585 isString: isString, 1586 isNumber: isNumber, 1587 isObject: isObject, 1588 isUndefined: isUndefined, 1589 isDate: isDate, 1590 isFile: isFile, 1591 isBlob: isBlob, 1592 isFunction: isFunction, 1593 isStream: isStream, 1594 isURLSearchParams: isURLSearchParams, 1595 isStandardBrowserEnv: isStandardBrowserEnv, 1596 forEach: forEach, 1597 merge: merge, 1598 extend: extend, 1599 trim: trim 1600}; 1601 1602 1603/***/ }), 1604
vendor: 564 bytes, lines 1605-1626
1605/***/ "./node_modules/is-buffer/index.js": 1606/*!*****************************************!*\ 1607 !*** ./node_modules/is-buffer/index.js ***! 1608 \*****************************************/ 1609/*! no static exports found */ 1610/***/ (function(module, exports) { 1611 1612/*! 1613 * Determine if an object is a Buffer 1614 * 1615 * @author Feross Aboukhadijeh <https://feross.org> 1616 * @license MIT 1617 */ 1618 1619module.exports = function isBuffer (obj) { 1620 return obj != null && obj.constructor != null && 1621 typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) 1622} 1623 1624 1625/***/ }), 1626
vendor: 5,681 bytes, lines 1627-1821
1627/***/ "./node_modules/process/browser.js": 1628/*!*****************************************!*\ 1629 !*** ./node_modules/process/browser.js ***! 1630 \*****************************************/ 1631/*! no static exports found */ 1632/***/ (function(module, exports) { 1633 1634// shim for using process in browser 1635var process = module.exports = {}; 1636 1637// cached from whatever global is present so that test runners that stub it 1638// don't break things. But we need to wrap it in a try catch in case it is 1639// wrapped in strict mode code which doesn't define any globals. It's inside a 1640// function because try/catches deoptimize in certain engines. 1641 1642var cachedSetTimeout; 1643var cachedClearTimeout; 1644 1645function defaultSetTimout() { 1646 throw new Error('setTimeout has not been defined'); 1647} 1648function defaultClearTimeout () { 1649 throw new Error('clearTimeout has not been defined'); 1650} 1651(function () { 1652 try { 1653 if (typeof setTimeout === 'function') { 1654 cachedSetTimeout = setTimeout; 1655 } else { 1656 cachedSetTimeout = defaultSetTimout; 1657 } 1658 } catch (e) { 1659 cachedSetTimeout = defaultSetTimout; 1660 } 1661 try { 1662 if (typeof clearTimeout === 'function') { 1663 cachedClearTimeout = clearTimeout; 1664 } else { 1665 cachedClearTimeout = defaultClearTimeout; 1666 } 1667 } catch (e) { 1668 cachedClearTimeout = defaultClearTimeout; 1669 } 1670} ()) 1671function runTimeout(fun) { 1672 if (cachedSetTimeout === setTimeout) { 1673 //normal enviroments in sane situations 1674 return setTimeout(fun, 0); 1675 } 1676 // if setTimeout wasn't available but was latter defined 1677 if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { 1678 cachedSetTimeout = setTimeout; 1679 return setTimeout(fun, 0); 1680 } 1681 try { 1682 // when when somebody has screwed with setTimeout but no I.E. maddness 1683 return cachedSetTimeout(fun, 0); 1684 } catch(e){ 1685 try { 1686 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 1687 return cachedSetTimeout.call(null, fun, 0); 1688 } catch(e){ 1689 // 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 1690 return cachedSetTimeout.call(this, fun, 0); 1691 } 1692 } 1693 1694 1695} 1696function runClearTimeout(marker) { 1697 if (cachedClearTimeout === clearTimeout) { 1698 //normal enviroments in sane situations 1699 return clearTimeout(marker); 1700 } 1701 // if clearTimeout wasn't available but was latter defined 1702 if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { 1703 cachedClearTimeout = clearTimeout; 1704 return clearTimeout(marker); 1705 } 1706 try { 1707 // when when somebody has screwed with setTimeout but no I.E. maddness 1708 return cachedClearTimeout(marker); 1709 } catch (e){ 1710 try { 1711 // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally 1712 return cachedClearTimeout.call(null, marker); 1713 } catch (e){ 1714 // 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. 1715 // Some versions of I.E. have different rules for clearTimeout vs setTimeout 1716 return cachedClearTimeout.call(this, marker); 1717 } 1718 } 1719 1720 1721 1722} 1723var queue = []; 1724var draining = false; 1725var currentQueue; 1726var queueIndex = -1; 1727 1728function cleanUpNextTick() { 1729 if (!draining || !currentQueue) { 1730 return; 1731 } 1732 draining = false; 1733 if (currentQueue.length) { 1734 queue = currentQueue.concat(queue); 1735 } else { 1736 queueIndex = -1; 1737 } 1738 if (queue.length) { 1739 drainQueue(); 1740 } 1741} 1742 1743function drainQueue() { 1744 if (draining) { 1745 return; 1746 } 1747 var timeout = runTimeout(cleanUpNextTick); 1748 draining = true; 1749 1750 var len = queue.length; 1751 while(len) { 1752 currentQueue = queue; 1753 queue = []; 1754 while (++queueIndex < len) { 1755 if (currentQueue) { 1756 currentQueue[queueIndex].run(); 1757 } 1758 } 1759 queueIndex = -1; 1760 len = queue.length; 1761 } 1762 currentQueue = null; 1763 draining = false; 1764 runClearTimeout(timeout); 1765} 1766 1767process.nextTick = function (fun) { 1768 var args = new Array(arguments.length - 1); 1769 if (arguments.length > 1) { 1770 for (var i = 1; i < arguments.length; i++) { 1771 args[i - 1] = arguments[i]; 1772 } 1773 } 1774 queue.push(new Item(fun, args)); 1775 if (queue.length === 1 && !draining) { 1776 runTimeout(drainQueue); 1777 } 1778}; 1779 1780// v8 likes predictible objects 1781function Item(fun, array) { 1782 this.fun = fun; 1783 this.array = array; 1784} 1785Item.prototype.run = function () { 1786 this.fun.apply(null, this.array); 1787}; 1788process.title = 'browser'; 1789process.browser = true; 1790process.env = {}; 1791process.argv = []; 1792process.version = ''; // empty string to avoid regexp issues 1793process.versions = {}; 1794 1795function noop() {} 1796 1797process.on = noop; 1798process.addListener = noop; 1799process.once = noop; 1800process.off = noop; 1801process.removeListener = noop; 1802process.removeAllListeners = noop; 1803process.emit = noop; 1804process.prependListener = noop; 1805process.prependOnceListener = noop; 1806 1807process.listeners = function (name) { return [] } 1808 1809process.binding = function (name) { 1810 throw new Error('process.binding is not supported'); 1811}; 1812 1813process.cwd = function () { return '/' }; 1814process.chdir = function (dir) { 1815 throw new Error('process.chdir is not supported'); 1816}; 1817process.umask = function() { return 0; }; 1818 1819 1820/***/ }), 1821
vendor: 7,087 bytes, lines 1822-2019
1822/***/ "./node_modules/setimmediate/setImmediate.js": 1823/*!***************************************************!*\ 1824 !*** ./node_modules/setimmediate/setImmediate.js ***! 1825 \***************************************************/ 1826/*! no static exports found */ 1827/***/ (function(module, exports, __webpack_require__) { 1828 1829/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) { 1830 "use strict"; 1831 1832 if (global.setImmediate) { 1833 return; 1834 } 1835 1836 var nextHandle = 1; // Spec says greater than zero 1837 var tasksByHandle = {}; 1838 var currentlyRunningATask = false; 1839 var doc = global.document; 1840 var registerImmediate; 1841 1842 function setImmediate(callback) { 1843 // Callback can either be a function or a string 1844 if (typeof callback !== "function") { 1845 callback = new Function("" + callback); 1846 } 1847 // Copy function arguments 1848 var args = new Array(arguments.length - 1); 1849 for (var i = 0; i < args.length; i++) { 1850 args[i] = arguments[i + 1]; 1851 } 1852 // Store and register the task 1853 var task = { callback: callback, args: args }; 1854 tasksByHandle[nextHandle] = task; 1855 registerImmediate(nextHandle); 1856 return nextHandle++; 1857 } 1858 1859 function clearImmediate(handle) { 1860 delete tasksByHandle[handle]; 1861 } 1862 1863 function run(task) { 1864 var callback = task.callback; 1865 var args = task.args; 1866 switch (args.length) { 1867 case 0: 1868 callback(); 1869 break; 1870 case 1: 1871 callback(args[0]); 1872 break; 1873 case 2: 1874 callback(args[0], args[1]); 1875 break; 1876 case 3: 1877 callback(args[0], args[1], args[2]); 1878 break; 1879 default: 1880 callback.apply(undefined, args); 1881 break; 1882 } 1883 } 1884 1885 function runIfPresent(handle) { 1886 // From the spec: "Wait until any invocations of this algorithm started before this one have completed." 1887 // So if we're currently running a task, we'll need to delay this invocation. 1888 if (currentlyRunningATask) { 1889 // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a 1890 // "too much recursion" error. 1891 setTimeout(runIfPresent, 0, handle); 1892 } else { 1893 var task = tasksByHandle[handle]; 1894 if (task) { 1895 currentlyRunningATask = true; 1896 try { 1897 run(task); 1898 } finally { 1899 clearImmediate(handle); 1900 currentlyRunningATask = false; 1901 } 1902 } 1903 } 1904 } 1905 1906 function installNextTickImplementation() { 1907 registerImmediate = function(handle) { 1908 process.nextTick(function () { runIfPresent(handle); }); 1909 }; 1910 } 1911 1912 function canUsePostMessage() { 1913 // The test against `importScripts` prevents this implementation from being installed inside a web worker, 1914 // where `global.postMessage` means something completely different and can't be used for this purpose. 1915 if (global.postMessage && !global.importScripts) { 1916 var postMessageIsAsynchronous = true; 1917 var oldOnMessage = global.onmessage; 1918 global.onmessage = function() { 1919 postMessageIsAsynchronous = false; 1920 }; 1921 global.postMessage("", "*"); 1922 global.onmessage = oldOnMessage; 1923 return postMessageIsAsynchronous; 1924 } 1925 } 1926 1927 function installPostMessageImplementation() { 1928 // Installs an event handler on `global` for the `message` event: see 1929 // * https://developer.mozilla.org/en/DOM/window.postMessage 1930 // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages 1931 1932 var messagePrefix = "setImmediate$" + Math.random() + "$"; 1933 var onGlobalMessage = function(event) { 1934 if (event.source === global && 1935 typeof event.data === "string" && 1936 event.data.indexOf(messagePrefix) === 0) { 1937 runIfPresent(+event.data.slice(messagePrefix.length)); 1938 } 1939 }; 1940 1941 if (global.addEventListener) { 1942 global.addEventListener("message", onGlobalMessage, false); 1943 } else { 1944 global.attachEvent("onmessage", onGlobalMessage); 1945 } 1946 1947 registerImmediate = function(handle) { 1948 global.postMessage(messagePrefix + handle, "*"); 1949 }; 1950 } 1951 1952 function installMessageChannelImplementation() { 1953 var channel = new MessageChannel(); 1954 channel.port1.onmessage = function(event) { 1955 var handle = event.data; 1956 runIfPresent(handle); 1957 }; 1958 1959 registerImmediate = function(handle) { 1960 channel.port2.postMessage(handle); 1961 }; 1962 } 1963 1964 function installReadyStateChangeImplementation() { 1965 var html = doc.documentElement; 1966 registerImmediate = function(handle) { 1967 // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted 1968 // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called. 1969 var script = doc.createElement("script"); 1970 script.onreadystatechange = function () { 1971 runIfPresent(handle); 1972 script.onreadystatechange = null; 1973 html.removeChild(script); 1974 script = null; 1975 }; 1976 html.appendChild(script); 1977 }; 1978 } 1979 1980 function installSetTimeoutImplementation() { 1981 registerImmediate = function(handle) { 1982 setTimeout(runIfPresent, 0, handle); 1983 }; 1984 } 1985 1986 // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live. 1987 var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global); 1988 attachTo = attachTo && attachTo.setTimeout ? attachTo : global; 1989 1990 // Don't get fooled by e.g. browserify environments. 1991 if ({}.toString.call(global.process) === "[object process]") { 1992 // For Node.js before 0.9 1993 installNextTickImplementation(); 1994 1995 } else if (canUsePostMessage()) { 1996 // For non-IE10 modern browsers 1997 installPostMessageImplementation(); 1998 1999 } else if (global.MessageChannel) { 2000 // For web workers, where supported 2001 installMessageChannelImplementation(); 2002 2003 } else if (doc && "onreadystatechange" in doc.createElement("script")) { 2004 // For IE 6â8 2005 installReadyStateChangeImplementation(); 2006 2007 } else { 2008 // For older browsers 2009 installSetTimeoutImplementation(); 2010 } 2011 2012 attachTo.setImmediate = setImmediate; 2013 attachTo.clearImmediate = clearImmediate; 2014}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self)); 2015 2016/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js"))) 2017 2018/***/ }), 2019
vendor: 2,587 bytes, lines 2020-2094
2020/***/ "./node_modules/timers-browserify/main.js": 2021/*!************************************************!*\ 2022 !*** ./node_modules/timers-browserify/main.js ***! 2023 \************************************************/ 2024/*! no static exports found */ 2025/***/ (function(module, exports, __webpack_require__) { 2026 2027/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) || 2028 (typeof self !== "undefined" && self) || 2029 window; 2030var apply = Function.prototype.apply; 2031 2032// DOM APIs, for completeness 2033 2034exports.setTimeout = function() { 2035 return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout); 2036}; 2037exports.setInterval = function() { 2038 return new Timeout(apply.call(setInterval, scope, arguments), clearInterval); 2039}; 2040exports.clearTimeout = 2041exports.clearInterval = function(timeout) { 2042 if (timeout) { 2043 timeout.close(); 2044 } 2045}; 2046 2047function Timeout(id, clearFn) { 2048 this._id = id; 2049 this._clearFn = clearFn; 2050} 2051Timeout.prototype.unref = Timeout.prototype.ref = function() {}; 2052Timeout.prototype.close = function() { 2053 this._clearFn.call(scope, this._id); 2054}; 2055 2056// Does not start the time, just sets up the members needed. 2057exports.enroll = function(item, msecs) { 2058 clearTimeout(item._idleTimeoutId); 2059 item._idleTimeout = msecs; 2060}; 2061 2062exports.unenroll = function(item) { 2063 clearTimeout(item._idleTimeoutId); 2064 item._idleTimeout = -1; 2065}; 2066 2067exports._unrefActive = exports.active = function(item) { 2068 clearTimeout(item._idleTimeoutId); 2069 2070 var msecs = item._idleTimeout; 2071 if (msecs >= 0) { 2072 item._idleTimeoutId = setTimeout(function onTimeout() { 2073 if (item._onTimeout) 2074 item._onTimeout(); 2075 }, msecs); 2076 } 2077}; 2078 2079// setimmediate attaches itself to the global object 2080__webpack_require__(/*! setimmediate */ "./node_modules/setimmediate/setImmediate.js"); 2081// On some exotic environments, it's not clear which object `setimmediate` was 2082// able to install onto. Search each possibility in the same order as the 2083// `setimmediate` library. 2084exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) || 2085 (typeof global !== "undefined" && global.setImmediate) || 2086 (this && this.setImmediate); 2087exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) || 2088 (typeof global !== "undefined" && global.clearImmediate) || 2089 (this && this.clearImmediate); 2090 2091/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 2092 2093/***/ }), 2094
vendor: 322,690 bytes, lines 2095-14115
2095/***/ "./node_modules/vue/dist/vue.common.dev.js": 2096/*!*************************************************!*\ 2097 !*** ./node_modules/vue/dist/vue.common.dev.js ***! 2098 \*************************************************/ 2099/*! no static exports found */ 2100/***/ (function(module, exports, __webpack_require__) { 2101 2102"use strict"; 2103/* WEBPACK VAR INJECTION */(function(global, setImmediate) {/*! 2104 * Vue.js v2.6.14 2105 * (c) 2014-2021 Evan You 2106 * Released under the MIT License. 2107 */ 2108 2109 2110/* */ 2111 2112var emptyObject = Object.freeze({}); 2113 2114// These helpers produce better VM code in JS engines due to their 2115// explicitness and function inlining. 2116function isUndef (v) { 2117 return v === undefined || v === null 2118} 2119 2120function isDef (v) { 2121 return v !== undefined && v !== null 2122} 2123 2124function isTrue (v) { 2125 return v === true 2126} 2127 2128function isFalse (v) { 2129 return v === false 2130} 2131 2132/** 2133 * Check if value is primitive. 2134 */ 2135function isPrimitive (value) { 2136 return ( 2137 typeof value === 'string' || 2138 typeof value === 'number' || 2139 // $flow-disable-line 2140 typeof value === 'symbol' || 2141 typeof value === 'boolean' 2142 ) 2143} 2144 2145/** 2146 * Quick object check - this is primarily used to tell 2147 * Objects from primitive values when we know the value 2148 * is a JSON-compliant type. 2149 */ 2150function isObject (obj) { 2151 return obj !== null && typeof obj === 'object' 2152} 2153 2154/** 2155 * Get the raw type string of a value, e.g., [object Object]. 2156 */ 2157var _toString = Object.prototype.toString; 2158 2159function toRawType (value) { 2160 return _toString.call(value).slice(8, -1) 2161} 2162 2163/** 2164 * Strict object type check. Only returns true 2165 * for plain JavaScript objects. 2166 */ 2167function isPlainObject (obj) { 2168 return _toString.call(obj) === '[object Object]' 2169} 2170 2171function isRegExp (v) { 2172 return _toString.call(v) === '[object RegExp]' 2173} 2174 2175/** 2176 * Check if val is a valid array index. 2177 */ 2178function isValidArrayIndex (val) { 2179 var n = parseFloat(String(val)); 2180 return n >= 0 && Math.floor(n) === n && isFinite(val) 2181} 2182 2183function isPromise (val) { 2184 return ( 2185 isDef(val) && 2186 typeof val.then === 'function' && 2187 typeof val.catch === 'function' 2188 ) 2189} 2190 2191/** 2192 * Convert a value to a string that is actually rendered. 2193 */ 2194function toString (val) { 2195 return val == null 2196 ? '' 2197 : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString) 2198 ? JSON.stringify(val, null, 2) 2199 : String(val) 2200} 2201 2202/** 2203 * Convert an input value to a number for persistence. 2204 * If the conversion fails, return original string. 2205 */ 2206function toNumber (val) { 2207 var n = parseFloat(val); 2208 return isNaN(n) ? val : n 2209} 2210 2211/** 2212 * Make a map and return a function for checking if a key 2213 * is in that map. 2214 */ 2215function makeMap ( 2216 str, 2217 expectsLowerCase 2218) { 2219 var map = Object.create(null); 2220 var list = str.split(','); 2221 for (var i = 0; i < list.length; i++) { 2222 map[list[i]] = true; 2223 } 2224 return expectsLowerCase 2225 ? function (val) { return map[val.toLowerCase()]; } 2226 : function (val) { return map[val]; } 2227} 2228 2229/** 2230 * Check if a tag is a built-in tag. 2231 */ 2232var isBuiltInTag = makeMap('slot,component', true); 2233 2234/** 2235 * Check if an attribute is a reserved attribute. 2236 */ 2237var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); 2238 2239/** 2240 * Remove an item from an array. 2241 */ 2242function remove (arr, item) { 2243 if (arr.length) { 2244 var index = arr.indexOf(item); 2245 if (index > -1) { 2246 return arr.splice(index, 1) 2247 } 2248 } 2249} 2250 2251/** 2252 * Check whether an object has the property. 2253 */ 2254var hasOwnProperty = Object.prototype.hasOwnProperty; 2255function hasOwn (obj, key) { 2256 return hasOwnProperty.call(obj, key) 2257} 2258 2259/** 2260 * Create a cached version of a pure function. 2261 */ 2262function cached (fn) { 2263 var cache = Object.create(null); 2264 return (function cachedFn (str) { 2265 var hit = cache[str]; 2266 return hit || (cache[str] = fn(str)) 2267 }) 2268} 2269 2270/** 2271 * Camelize a hyphen-delimited string. 2272 */ 2273var camelizeRE = /-(\w)/g; 2274var camelize = cached(function (str) { 2275 return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; }) 2276}); 2277 2278/** 2279 * Capitalize a string. 2280 */ 2281var capitalize = cached(function (str) { 2282 return str.charAt(0).toUpperCase() + str.slice(1) 2283}); 2284 2285/** 2286 * Hyphenate a camelCase string. 2287 */ 2288var hyphenateRE = /\B([A-Z])/g; 2289var hyphenate = cached(function (str) { 2290 return str.replace(hyphenateRE, '-$1').toLowerCase() 2291}); 2292 2293/** 2294 * Simple bind polyfill for environments that do not support it, 2295 * e.g., PhantomJS 1.x. Technically, we don't need this anymore 2296 * since native bind is now performant enough in most browsers. 2297 * But removing it would mean breaking code that was able to run in 2298 * PhantomJS 1.x, so this must be kept for backward compatibility. 2299 */ 2300 2301/* istanbul ignore next */ 2302function polyfillBind (fn, ctx) { 2303 function boundFn (a) { 2304 var l = arguments.length; 2305 return l 2306 ? l > 1 2307 ? fn.apply(ctx, arguments) 2308 : fn.call(ctx, a) 2309 : fn.call(ctx) 2310 } 2311 2312 boundFn._length = fn.length; 2313 return boundFn 2314} 2315 2316function nativeBind (fn, ctx) { 2317 return fn.bind(ctx) 2318} 2319 2320var bind = Function.prototype.bind 2321 ? nativeBind 2322 : polyfillBind; 2323 2324/** 2325 * Convert an Array-like object to a real Array. 2326 */ 2327function toArray (list, start) { 2328 start = start || 0; 2329 var i = list.length - start; 2330 var ret = new Array(i); 2331 while (i--) { 2332 ret[i] = list[i + start]; 2333 } 2334 return ret 2335} 2336 2337/** 2338 * Mix properties into target object. 2339 */ 2340function extend (to, _from) { 2341 for (var key in _from) { 2342 to[key] = _from[key]; 2343 } 2344 return to 2345} 2346 2347/** 2348 * Merge an Array of Objects into a single Object. 2349 */ 2350function toObject (arr) { 2351 var res = {}; 2352 for (var i = 0; i < arr.length; i++) { 2353 if (arr[i]) { 2354 extend(res, arr[i]); 2355 } 2356 } 2357 return res 2358} 2359 2360/* eslint-disable no-unused-vars */ 2361 2362/** 2363 * Perform no operation. 2364 * Stubbing args to make Flow happy without leaving useless transpiled code 2365 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/). 2366 */ 2367function noop (a, b, c) {} 2368 2369/** 2370 * Always return false. 2371 */ 2372var no = function (a, b, c) { return false; }; 2373 2374/* eslint-enable no-unused-vars */ 2375 2376/** 2377 * Return the same value. 2378 */ 2379var identity = function (_) { return _; }; 2380 2381/** 2382 * Generate a string containing static keys from compiler modules. 2383 */ 2384function genStaticKeys (modules) { 2385 return modules.reduce(function (keys, m) { 2386 return keys.concat(m.staticKeys || []) 2387 }, []).join(',') 2388} 2389 2390/** 2391 * Check if two values are loosely equal - that is, 2392 * if they are plain objects, do they have the same shape? 2393 */ 2394function looseEqual (a, b) { 2395 if (a === b) { return true } 2396 var isObjectA = isObject(a); 2397 var isObjectB = isObject(b); 2398 if (isObjectA && isObjectB) { 2399 try { 2400 var isArrayA = Array.isArray(a); 2401 var isArrayB = Array.isArray(b); 2402 if (isArrayA && isArrayB) { 2403 return a.length === b.length && a.every(function (e, i) { 2404 return looseEqual(e, b[i]) 2405 }) 2406 } else if (a instanceof Date && b instanceof Date) { 2407 return a.getTime() === b.getTime() 2408 } else if (!isArrayA && !isArrayB) { 2409 var keysA = Object.keys(a); 2410 var keysB = Object.keys(b); 2411 return keysA.length === keysB.length && keysA.every(function (key) { 2412 return looseEqual(a[key], b[key]) 2413 }) 2414 } else { 2415 /* istanbul ignore next */ 2416 return false 2417 } 2418 } catch (e) { 2419 /* istanbul ignore next */ 2420 return false 2421 } 2422 } else if (!isObjectA && !isObjectB) { 2423 return String(a) === String(b) 2424 } else { 2425 return false 2426 } 2427} 2428 2429/** 2430 * Return the first index at which a loosely equal value can be 2431 * found in the array (if value is a plain object, the array must 2432 * contain an object of the same shape), or -1 if it is not present. 2433 */ 2434function looseIndexOf (arr, val) { 2435 for (var i = 0; i < arr.length; i++) { 2436 if (looseEqual(arr[i], val)) { return i } 2437 } 2438 return -1 2439} 2440 2441/** 2442 * Ensure a function is called only once. 2443 */ 2444function once (fn) { 2445 var called = false; 2446 return function () { 2447 if (!called) { 2448 called = true; 2449 fn.apply(this, arguments); 2450 } 2451 } 2452} 2453 2454var SSR_ATTR = 'data-server-rendered'; 2455 2456var ASSET_TYPES = [ 2457 'component', 2458 'directive', 2459 'filter' 2460]; 2461 2462var LIFECYCLE_HOOKS = [ 2463 'beforeCreate', 2464 'created', 2465 'beforeMount', 2466 'mounted', 2467 'beforeUpdate', 2468 'updated', 2469 'beforeDestroy', 2470 'destroyed', 2471 'activated', 2472 'deactivated', 2473 'errorCaptured', 2474 'serverPrefetch' 2475]; 2476 2477/* */ 2478 2479 2480 2481var config = ({ 2482 /** 2483 * Option merge strategies (used in core/util/options) 2484 */ 2485 // $flow-disable-line 2486 optionMergeStrategies: Object.create(null), 2487 2488 /** 2489 * Whether to suppress warnings. 2490 */ 2491 silent: false, 2492 2493 /** 2494 * Show production mode tip message on boot? 2495 */ 2496 productionTip: "development" !== 'production', 2497 2498 /** 2499 * Whether to enable devtools 2500 */ 2501 devtools: "development" !== 'production', 2502 2503 /** 2504 * Whether to record perf 2505 */ 2506 performance: false, 2507 2508 /** 2509 * Error handler for watcher errors 2510 */ 2511 errorHandler: null, 2512 2513 /** 2514 * Warn handler for watcher warns 2515 */ 2516 warnHandler: null, 2517 2518 /** 2519 * Ignore certain custom elements 2520 */ 2521 ignoredElements: [], 2522 2523 /** 2524 * Custom user key aliases for v-on 2525 */ 2526 // $flow-disable-line 2527 keyCodes: Object.create(null), 2528 2529 /** 2530 * Check if a tag is reserved so that it cannot be registered as a 2531 * component. This is platform-dependent and may be overwritten. 2532 */ 2533 isReservedTag: no, 2534 2535 /** 2536 * Check if an attribute is reserved so that it cannot be used as a component 2537 * prop. This is platform-dependent and may be overwritten. 2538 */ 2539 isReservedAttr: no, 2540 2541 /** 2542 * Check if a tag is an unknown element. 2543 * Platform-dependent. 2544 */ 2545 isUnknownElement: no, 2546 2547 /** 2548 * Get the namespace of an element 2549 */ 2550 getTagNamespace: noop, 2551 2552 /** 2553 * Parse the real tag name for the specific platform. 2554 */ 2555 parsePlatformTagName: identity, 2556 2557 /** 2558 * Check if an attribute must be bound using property, e.g. value 2559 * Platform-dependent. 2560 */ 2561 mustUseProp: no, 2562 2563 /** 2564 * Perform updates asynchronously. Intended to be used by Vue Test Utils 2565 * This will significantly reduce performance if set to false. 2566 */ 2567 async: true, 2568 2569 /** 2570 * Exposed for legacy reasons 2571 */ 2572 _lifecycleHooks: LIFECYCLE_HOOKS 2573}); 2574 2575/* */ 2576 2577/** 2578 * unicode letters used for parsing html tags, component names and property paths. 2579 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname 2580 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS 2581 */ 2582var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/; 2583 2584/** 2585 * Check if a string starts with $ or _ 2586 */ 2587function isReserved (str) { 2588 var c = (str + '').charCodeAt(0); 2589 return c === 0x24 || c === 0x5F 2590} 2591 2592/** 2593 * Define a property. 2594 */ 2595function def (obj, key, val, enumerable) { 2596 Object.defineProperty(obj, key, { 2597 value: val, 2598 enumerable: !!enumerable, 2599 writable: true, 2600 configurable: true 2601 }); 2602} 2603 2604/** 2605 * Parse simple path. 2606 */ 2607var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]")); 2608function parsePath (path) { 2609 if (bailRE.test(path)) { 2610 return 2611 } 2612 var segments = path.split('.'); 2613 return function (obj) { 2614 for (var i = 0; i < segments.length; i++) { 2615 if (!obj) { return } 2616 obj = obj[segments[i]]; 2617 } 2618 return obj 2619 } 2620} 2621 2622/* */ 2623 2624// can we use __proto__? 2625var hasProto = '__proto__' in {}; 2626 2627// Browser environment sniffing 2628var inBrowser = typeof window !== 'undefined'; 2629var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; 2630var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); 2631var UA = inBrowser && window.navigator.userAgent.toLowerCase(); 2632var isIE = UA && /msie|trident/.test(UA); 2633var isIE9 = UA && UA.indexOf('msie 9.0') > 0; 2634var isEdge = UA && UA.indexOf('edge/') > 0; 2635var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android'); 2636var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios'); 2637var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; 2638var isPhantomJS = UA && /phantomjs/.test(UA); 2639var isFF = UA && UA.match(/firefox\/(\d+)/); 2640 2641// Firefox has a "watch" function on Object.prototype... 2642var nativeWatch = ({}).watch; 2643 2644var supportsPassive = false; 2645if (inBrowser) { 2646 try { 2647 var opts = {}; 2648 Object.defineProperty(opts, 'passive', ({ 2649 get: function get () { 2650 /* istanbul ignore next */ 2651 supportsPassive = true; 2652 } 2653 })); // https://github.com/facebook/flow/issues/285 2654 window.addEventListener('test-passive', null, opts); 2655 } catch (e) {} 2656} 2657 2658// this needs to be lazy-evaled because vue may be required before 2659// vue-server-renderer can set VUE_ENV 2660var _isServer; 2661var isServerRendering = function () { 2662 if (_isServer === undefined) { 2663 /* istanbul ignore if */ 2664 if (!inBrowser && !inWeex && typeof global !== 'undefined') { 2665 // detect presence of vue-server-renderer and avoid 2666 // Webpack shimming the process 2667 _isServer = global['process'] && global['process'].env.VUE_ENV === 'server'; 2668 } else { 2669 _isServer = false; 2670 } 2671 } 2672 return _isServer 2673}; 2674 2675// detect devtools 2676var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; 2677 2678/* istanbul ignore next */ 2679function isNative (Ctor) { 2680 return typeof Ctor === 'function' && /native code/.test(Ctor.toString()) 2681} 2682 2683var hasSymbol = 2684 typeof Symbol !== 'undefined' && isNative(Symbol) && 2685 typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); 2686 2687var _Set; 2688/* istanbul ignore if */ // $flow-disable-line 2689if (typeof Set !== 'undefined' && isNative(Set)) { 2690 // use native Set when available. 2691 _Set = Set; 2692} else { 2693 // a non-standard Set polyfill that only works with primitive keys. 2694 _Set = /*@__PURE__*/(function () { 2695 function Set () { 2696 this.set = Object.create(null); 2697 } 2698 Set.prototype.has = function has (key) { 2699 return this.set[key] === true 2700 }; 2701 Set.prototype.add = function add (key) { 2702 this.set[key] = true; 2703 }; 2704 Set.prototype.clear = function clear () { 2705 this.set = Object.create(null); 2706 }; 2707 2708 return Set; 2709 }()); 2710} 2711 2712/* */ 2713 2714var warn = noop; 2715var tip = noop; 2716var generateComponentTrace = (noop); // work around flow check 2717var formatComponentName = (noop); 2718 2719{ 2720 var hasConsole = typeof console !== 'undefined'; 2721 var classifyRE = /(?:^|[-_])(\w)/g; 2722 var classify = function (str) { return str 2723 .replace(classifyRE, function (c) { return c.toUpperCase(); }) 2724 .replace(/[-_]/g, ''); }; 2725 2726 warn = function (msg, vm) { 2727 var trace = vm ? generateComponentTrace(vm) : ''; 2728 2729 if (config.warnHandler) { 2730 config.warnHandler.call(null, msg, vm, trace); 2731 } else if (hasConsole && (!config.silent)) { 2732 console.error(("[Vue warn]: " + msg + trace)); 2733 } 2734 }; 2735 2736 tip = function (msg, vm) { 2737 if (hasConsole && (!config.silent)) { 2738 console.warn("[Vue tip]: " + msg + ( 2739 vm ? generateComponentTrace(vm) : '' 2740 )); 2741 } 2742 }; 2743 2744 formatComponentName = function (vm, includeFile) { 2745 if (vm.$root === vm) { 2746 return '<Root>' 2747 } 2748 var options = typeof vm === 'function' && vm.cid != null 2749 ? vm.options 2750 : vm._isVue 2751 ? vm.$options || vm.constructor.options 2752 : vm; 2753 var name = options.name || options._componentTag; 2754 var file = options.__file; 2755 if (!name && file) { 2756 var match = file.match(/([^/\\]+)\.vue$/); 2757 name = match && match[1]; 2758 } 2759 2760 return ( 2761 (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") + 2762 (file && includeFile !== false ? (" at " + file) : '') 2763 ) 2764 }; 2765 2766 var repeat = function (str, n) { 2767 var res = ''; 2768 while (n) { 2769 if (n % 2 === 1) { res += str; } 2770 if (n > 1) { str += str; } 2771 n >>= 1; 2772 } 2773 return res 2774 }; 2775 2776 generateComponentTrace = function (vm) { 2777 if (vm._isVue && vm.$parent) { 2778 var tree = []; 2779 var currentRecursiveSequence = 0; 2780 while (vm) { 2781 if (tree.length > 0) { 2782 var last = tree[tree.length - 1]; 2783 if (last.constructor === vm.constructor) { 2784 currentRecursiveSequence++; 2785 vm = vm.$parent; 2786 continue 2787 } else if (currentRecursiveSequence > 0) { 2788 tree[tree.length - 1] = [last, currentRecursiveSequence]; 2789 currentRecursiveSequence = 0; 2790 } 2791 } 2792 tree.push(vm); 2793 vm = vm.$parent; 2794 } 2795 return '\n\nfound in\n\n' + tree 2796 .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm) 2797 ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)") 2798 : formatComponentName(vm))); }) 2799 .join('\n') 2800 } else { 2801 return ("\n\n(found in " + (formatComponentName(vm)) + ")") 2802 } 2803 }; 2804} 2805 2806/* */ 2807 2808var uid = 0; 2809 2810/** 2811 * A dep is an observable that can have multiple 2812 * directives subscribing to it. 2813 */ 2814var Dep = function Dep () { 2815 this.id = uid++; 2816 this.subs = []; 2817}; 2818 2819Dep.prototype.addSub = function addSub (sub) { 2820 this.subs.push(sub); 2821}; 2822 2823Dep.prototype.removeSub = function removeSub (sub) { 2824 remove(this.subs, sub); 2825}; 2826 2827Dep.prototype.depend = function depend () { 2828 if (Dep.target) { 2829 Dep.target.addDep(this); 2830 } 2831}; 2832 2833Dep.prototype.notify = function notify () { 2834 // stabilize the subscriber list first 2835 var subs = this.subs.slice(); 2836 if (!config.async) { 2837 // subs aren't sorted in scheduler if not running async 2838 // we need to sort them now to make sure they fire in correct 2839 // order 2840 subs.sort(function (a, b) { return a.id - b.id; }); 2841 } 2842 for (var i = 0, l = subs.length; i < l; i++) { 2843 subs[i].update(); 2844 } 2845}; 2846 2847// The current target watcher being evaluated. 2848// This is globally unique because only one watcher 2849// can be evaluated at a time. 2850Dep.target = null; 2851var targetStack = []; 2852 2853function pushTarget (target) { 2854 targetStack.push(target); 2855 Dep.target = target; 2856} 2857 2858function popTarget () { 2859 targetStack.pop(); 2860 Dep.target = targetStack[targetStack.length - 1]; 2861} 2862 2863/* */ 2864 2865var VNode = function VNode ( 2866 tag, 2867 data, 2868 children, 2869 text, 2870 elm, 2871 context, 2872 componentOptions, 2873 asyncFactory 2874) { 2875 this.tag = tag; 2876 this.data = data; 2877 this.children = children; 2878 this.text = text; 2879 this.elm = elm; 2880 this.ns = undefined; 2881 this.context = context; 2882 this.fnContext = undefined; 2883 this.fnOptions = undefined; 2884 this.fnScopeId = undefined; 2885 this.key = data && data.key; 2886 this.componentOptions = componentOptions; 2887 this.componentInstance = undefined; 2888 this.parent = undefined; 2889 this.raw = false; 2890 this.isStatic = false; 2891 this.isRootInsert = true; 2892 this.isComment = false; 2893 this.isCloned = false; 2894 this.isOnce = false; 2895 this.asyncFactory = asyncFactory; 2896 this.asyncMeta = undefined; 2897 this.isAsyncPlaceholder = false; 2898}; 2899 2900var prototypeAccessors = { child: { configurable: true } }; 2901 2902// DEPRECATED: alias for componentInstance for backwards compat. 2903/* istanbul ignore next */ 2904prototypeAccessors.child.get = function () { 2905 return this.componentInstance 2906}; 2907 2908Object.defineProperties( VNode.prototype, prototypeAccessors ); 2909 2910var createEmptyVNode = function (text) { 2911 if ( text === void 0 ) text = ''; 2912 2913 var node = new VNode(); 2914 node.text = text; 2915 node.isComment = true; 2916 return node 2917}; 2918 2919function createTextVNode (val) { 2920 return new VNode(undefined, undefined, undefined, String(val)) 2921} 2922 2923// optimized shallow clone 2924// used for static nodes and slot nodes because they may be reused across 2925// multiple renders, cloning them avoids errors when DOM manipulations rely 2926// on their elm reference. 2927function cloneVNode (vnode) { 2928 var cloned = new VNode( 2929 vnode.tag, 2930 vnode.data, 2931 // #7975 2932 // clone children array to avoid mutating original in case of cloning 2933 // a child. 2934 vnode.children && vnode.children.slice(), 2935 vnode.text, 2936 vnode.elm, 2937 vnode.context, 2938 vnode.componentOptions, 2939 vnode.asyncFactory 2940 ); 2941 cloned.ns = vnode.ns; 2942 cloned.isStatic = vnode.isStatic; 2943 cloned.key = vnode.key; 2944 cloned.isComment = vnode.isComment; 2945 cloned.fnContext = vnode.fnContext; 2946 cloned.fnOptions = vnode.fnOptions; 2947 cloned.fnScopeId = vnode.fnScopeId; 2948 cloned.asyncMeta = vnode.asyncMeta; 2949 cloned.isCloned = true; 2950 return cloned 2951} 2952 2953/* 2954 * not type checking this file because flow doesn't play well with 2955 * dynamically accessing methods on Array prototype 2956 */ 2957 2958var arrayProto = Array.prototype; 2959var arrayMethods = Object.create(arrayProto); 2960 2961var methodsToPatch = [ 2962 'push', 2963 'pop', 2964 'shift', 2965 'unshift', 2966 'splice', 2967 'sort', 2968 'reverse' 2969]; 2970 2971/** 2972 * Intercept mutating methods and emit events 2973 */ 2974methodsToPatch.forEach(function (method) { 2975 // cache original method 2976 var original = arrayProto[method]; 2977 def(arrayMethods, method, function mutator () { 2978 var args = [], len = arguments.length; 2979 while ( len-- ) args[ len ] = arguments[ len ]; 2980 2981 var result = original.apply(this, args); 2982 var ob = this.__ob__; 2983 var inserted; 2984 switch (method) { 2985 case 'push': 2986 case 'unshift': 2987 inserted = args; 2988 break 2989 case 'splice': 2990 inserted = args.slice(2); 2991 break 2992 } 2993 if (inserted) { ob.observeArray(inserted); } 2994 // notify change 2995 ob.dep.notify(); 2996 return result 2997 }); 2998}); 2999 3000/* */ 3001 3002var arrayKeys = Object.getOwnPropertyNames(arrayMethods); 3003 3004/** 3005 * In some cases we may want to disable observation inside a component's 3006 * update computation. 3007 */ 3008var shouldObserve = true; 3009 3010function toggleObserving (value) { 3011 shouldObserve = value; 3012} 3013 3014/** 3015 * Observer class that is attached to each observed 3016 * object. Once attached, the observer converts the target 3017 * object's property keys into getter/setters that 3018 * collect dependencies and dispatch updates. 3019 */ 3020var Observer = function Observer (value) { 3021 this.value = value; 3022 this.dep = new Dep(); 3023 this.vmCount = 0; 3024 def(value, '__ob__', this); 3025 if (Array.isArray(value)) { 3026 if (hasProto) { 3027 protoAugment(value, arrayMethods); 3028 } else { 3029 copyAugment(value, arrayMethods, arrayKeys); 3030 } 3031 this.observeArray(value); 3032 } else { 3033 this.walk(value); 3034 } 3035}; 3036 3037/** 3038 * Walk through all properties and convert them into 3039 * getter/setters. This method should only be called when 3040 * value type is Object. 3041 */ 3042Observer.prototype.walk = function walk (obj) { 3043 var keys = Object.keys(obj); 3044 for (var i = 0; i < keys.length; i++) { 3045 defineReactive$$1(obj, keys[i]); 3046 } 3047}; 3048 3049/** 3050 * Observe a list of Array items. 3051 */ 3052Observer.prototype.observeArray = function observeArray (items) { 3053 for (var i = 0, l = items.length; i < l; i++) { 3054 observe(items[i]); 3055 } 3056}; 3057 3058// helpers 3059 3060/** 3061 * Augment a target Object or Array by intercepting 3062 * the prototype chain using __proto__ 3063 */ 3064function protoAugment (target, src) { 3065 /* eslint-disable no-proto */ 3066 target.__proto__ = src; 3067 /* eslint-enable no-proto */ 3068} 3069 3070/** 3071 * Augment a target Object or Array by defining 3072 * hidden properties. 3073 */ 3074/* istanbul ignore next */ 3075function copyAugment (target, src, keys) { 3076 for (var i = 0, l = keys.length; i < l; i++) { 3077 var key = keys[i]; 3078 def(target, key, src[key]); 3079 } 3080} 3081 3082/** 3083 * Attempt to create an observer instance for a value, 3084 * returns the new observer if successfully observed, 3085 * or the existing observer if the value already has one. 3086 */ 3087function observe (value, asRootData) { 3088 if (!isObject(value) || value instanceof VNode) { 3089 return 3090 } 3091 var ob; 3092 if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { 3093 ob = value.__ob__; 3094 } else if ( 3095 shouldObserve && 3096 !isServerRendering() && 3097 (Array.isArray(value) || isPlainObject(value)) && 3098 Object.isExtensible(value) && 3099 !value._isVue 3100 ) { 3101 ob = new Observer(value); 3102 } 3103 if (asRootData && ob) { 3104 ob.vmCount++; 3105 } 3106 return ob 3107} 3108 3109/** 3110 * Define a reactive property on an Object. 3111 */ 3112function defineReactive$$1 ( 3113 obj, 3114 key, 3115 val, 3116 customSetter, 3117 shallow 3118) { 3119 var dep = new Dep(); 3120 3121 var property = Object.getOwnPropertyDescriptor(obj, key); 3122 if (property && property.configurable === false) { 3123 return 3124 } 3125 3126 // cater for pre-defined getter/setters 3127 var getter = property && property.get; 3128 var setter = property && property.set; 3129 if ((!getter || setter) && arguments.length === 2) { 3130 val = obj[key]; 3131 } 3132 3133 var childOb = !shallow && observe(val); 3134 Object.defineProperty(obj, key, { 3135 enumerable: true, 3136 configurable: true, 3137 get: function reactiveGetter () { 3138 var value = getter ? getter.call(obj) : val; 3139 if (Dep.target) { 3140 dep.depend(); 3141 if (childOb) { 3142 childOb.dep.depend(); 3143 if (Array.isArray(value)) { 3144 dependArray(value); 3145 } 3146 } 3147 } 3148 return value 3149 }, 3150 set: function reactiveSetter (newVal) { 3151 var value = getter ? getter.call(obj) : val; 3152 /* eslint-disable no-self-compare */ 3153 if (newVal === value || (newVal !== newVal && value !== value)) { 3154 return 3155 } 3156 /* eslint-enable no-self-compare */ 3157 if (customSetter) { 3158 customSetter(); 3159 } 3160 // #7981: for accessor properties without setter 3161 if (getter && !setter) { return } 3162 if (setter) { 3163 setter.call(obj, newVal); 3164 } else { 3165 val = newVal; 3166 } 3167 childOb = !shallow && observe(newVal); 3168 dep.notify(); 3169 } 3170 }); 3171} 3172 3173/** 3174 * Set a property on an object. Adds the new property and 3175 * triggers change notification if the property doesn't 3176 * already exist. 3177 */ 3178function set (target, key, val) { 3179 if (isUndef(target) || isPrimitive(target) 3180 ) { 3181 warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target)))); 3182 } 3183 if (Array.isArray(target) && isValidArrayIndex(key)) { 3184 target.length = Math.max(target.length, key); 3185 target.splice(key, 1, val); 3186 return val 3187 } 3188 if (key in target && !(key in Object.prototype)) { 3189 target[key] = val; 3190 return val 3191 } 3192 var ob = (target).__ob__; 3193 if (target._isVue || (ob && ob.vmCount)) { 3194 warn( 3195 'Avoid adding reactive properties to a Vue instance or its root $data ' + 3196 'at runtime - declare it upfront in the data option.' 3197 ); 3198 return val 3199 } 3200 if (!ob) { 3201 target[key] = val; 3202 return val 3203 } 3204 defineReactive$$1(ob.value, key, val); 3205 ob.dep.notify(); 3206 return val 3207} 3208 3209/** 3210 * Delete a property and trigger change if necessary. 3211 */ 3212function del (target, key) { 3213 if (isUndef(target) || isPrimitive(target) 3214 ) { 3215 warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target)))); 3216 } 3217 if (Array.isArray(target) && isValidArrayIndex(key)) { 3218 target.splice(key, 1); 3219 return 3220 } 3221 var ob = (target).__ob__; 3222 if (target._isVue || (ob && ob.vmCount)) { 3223 warn( 3224 'Avoid deleting properties on a Vue instance or its root $data ' + 3225 '- just set it to null.' 3226 ); 3227 return 3228 } 3229 if (!hasOwn(target, key)) { 3230 return 3231 } 3232 delete target[key]; 3233 if (!ob) { 3234 return 3235 } 3236 ob.dep.notify(); 3237} 3238 3239/** 3240 * Collect dependencies on array elements when the array is touched, since 3241 * we cannot intercept array element access like property getters. 3242 */ 3243function dependArray (value) { 3244 for (var e = (void 0), i = 0, l = value.length; i < l; i++) { 3245 e = value[i]; 3246 e && e.__ob__ && e.__ob__.dep.depend(); 3247 if (Array.isArray(e)) { 3248 dependArray(e); 3249 } 3250 } 3251} 3252 3253/* */ 3254 3255/** 3256 * Option overwriting strategies are functions that handle 3257 * how to merge a parent option value and a child option 3258 * value into the final value. 3259 */ 3260var strats = config.optionMergeStrategies; 3261 3262/** 3263 * Options with restrictions 3264 */ 3265{ 3266 strats.el = strats.propsData = function (parent, child, vm, key) { 3267 if (!vm) { 3268 warn( 3269 "option \"" + key + "\" can only be used during instance " + 3270 'creation with the `new` keyword.' 3271 ); 3272 } 3273 return defaultStrat(parent, child) 3274 }; 3275} 3276 3277/** 3278 * Helper that recursively merges two data objects together. 3279 */ 3280function mergeData (to, from) { 3281 if (!from) { return to } 3282 var key, toVal, fromVal; 3283 3284 var keys = hasSymbol 3285 ? Reflect.ownKeys(from) 3286 : Object.keys(from); 3287 3288 for (var i = 0; i < keys.length; i++) { 3289 key = keys[i]; 3290 // in case the object is already observed... 3291 if (key === '__ob__') { continue } 3292 toVal = to[key]; 3293 fromVal = from[key]; 3294 if (!hasOwn(to, key)) { 3295 set(to, key, fromVal); 3296 } else if ( 3297 toVal !== fromVal && 3298 isPlainObject(toVal) && 3299 isPlainObject(fromVal) 3300 ) { 3301 mergeData(toVal, fromVal); 3302 } 3303 } 3304 return to 3305} 3306 3307/** 3308 * Data 3309 */ 3310function mergeDataOrFn ( 3311 parentVal, 3312 childVal, 3313 vm 3314) { 3315 if (!vm) { 3316 // in a Vue.extend merge, both should be functions 3317 if (!childVal) { 3318 return parentVal 3319 } 3320 if (!parentVal) { 3321 return childVal 3322 } 3323 // when parentVal & childVal are both present, 3324 // we need to return a function that returns the 3325 // merged result of both functions... no need to 3326 // check if parentVal is a function here because 3327 // it has to be a function to pass previous merges. 3328 return function mergedDataFn () { 3329 return mergeData( 3330 typeof childVal === 'function' ? childVal.call(this, this) : childVal, 3331 typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal 3332 ) 3333 } 3334 } else { 3335 return function mergedInstanceDataFn () { 3336 // instance merge 3337 var instanceData = typeof childVal === 'function' 3338 ? childVal.call(vm, vm) 3339 : childVal; 3340 var defaultData = typeof parentVal === 'function' 3341 ? parentVal.call(vm, vm) 3342 : parentVal; 3343 if (instanceData) { 3344 return mergeData(instanceData, defaultData) 3345 } else { 3346 return defaultData 3347 } 3348 } 3349 } 3350} 3351 3352strats.data = function ( 3353 parentVal, 3354 childVal, 3355 vm 3356) { 3357 if (!vm) { 3358 if (childVal && typeof childVal !== 'function') { 3359 warn( 3360 'The "data" option should be a function ' + 3361 'that returns a per-instance value in component ' + 3362 'definitions.', 3363 vm 3364 ); 3365 3366 return parentVal 3367 } 3368 return mergeDataOrFn(parentVal, childVal) 3369 } 3370 3371 return mergeDataOrFn(parentVal, childVal, vm) 3372}; 3373 3374/** 3375 * Hooks and props are merged as arrays. 3376 */ 3377function mergeHook ( 3378 parentVal, 3379 childVal 3380) { 3381 var res = childVal 3382 ? parentVal 3383 ? parentVal.concat(childVal) 3384 : Array.isArray(childVal) 3385 ? childVal 3386 : [childVal] 3387 : parentVal; 3388 return res 3389 ? dedupeHooks(res) 3390 : res 3391} 3392 3393function dedupeHooks (hooks) { 3394 var res = []; 3395 for (var i = 0; i < hooks.length; i++) { 3396 if (res.indexOf(hooks[i]) === -1) { 3397 res.push(hooks[i]); 3398 } 3399 } 3400 return res 3401} 3402 3403LIFECYCLE_HOOKS.forEach(function (hook) { 3404 strats[hook] = mergeHook; 3405}); 3406 3407/** 3408 * Assets 3409 * 3410 * When a vm is present (instance creation), we need to do 3411 * a three-way merge between constructor options, instance 3412 * options and parent options. 3413 */ 3414function mergeAssets ( 3415 parentVal, 3416 childVal, 3417 vm, 3418 key 3419) { 3420 var res = Object.create(parentVal || null); 3421 if (childVal) { 3422 assertObjectType(key, childVal, vm); 3423 return extend(res, childVal) 3424 } else { 3425 return res 3426 } 3427} 3428 3429ASSET_TYPES.forEach(function (type) { 3430 strats[type + 's'] = mergeAssets; 3431}); 3432 3433/** 3434 * Watchers. 3435 * 3436 * Watchers hashes should not overwrite one 3437 * another, so we merge them as arrays. 3438 */ 3439strats.watch = function ( 3440 parentVal, 3441 childVal, 3442 vm, 3443 key 3444) { 3445 // work around Firefox's Object.prototype.watch... 3446 if (parentVal === nativeWatch) { parentVal = undefined; } 3447 if (childVal === nativeWatch) { childVal = undefined; } 3448 /* istanbul ignore if */ 3449 if (!childVal) { return Object.create(parentVal || null) } 3450 { 3451 assertObjectType(key, childVal, vm); 3452 } 3453 if (!parentVal) { return childVal } 3454 var ret = {}; 3455 extend(ret, parentVal); 3456 for (var key$1 in childVal) { 3457 var parent = ret[key$1]; 3458 var child = childVal[key$1]; 3459 if (parent && !Array.isArray(parent)) { 3460 parent = [parent]; 3461 } 3462 ret[key$1] = parent 3463 ? parent.concat(child) 3464 : Array.isArray(child) ? child : [child]; 3465 } 3466 return ret 3467}; 3468 3469/** 3470 * Other object hashes. 3471 */ 3472strats.props = 3473strats.methods = 3474strats.inject = 3475strats.computed = function ( 3476 parentVal, 3477 childVal, 3478 vm, 3479 key 3480) { 3481 if (childVal && "development" !== 'production') { 3482 assertObjectType(key, childVal, vm); 3483 } 3484 if (!parentVal) { return childVal } 3485 var ret = Object.create(null); 3486 extend(ret, parentVal); 3487 if (childVal) { extend(ret, childVal); } 3488 return ret 3489}; 3490strats.provide = mergeDataOrFn; 3491 3492/** 3493 * Default strategy. 3494 */ 3495var defaultStrat = function (parentVal, childVal) { 3496 return childVal === undefined 3497 ? parentVal 3498 : childVal 3499}; 3500 3501/** 3502 * Validate component names 3503 */ 3504function checkComponents (options) { 3505 for (var key in options.components) { 3506 validateComponentName(key); 3507 } 3508} 3509 3510function validateComponentName (name) { 3511 if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) { 3512 warn( 3513 'Invalid component name: "' + name + '". Component names ' + 3514 'should conform to valid custom element name in html5 specification.' 3515 ); 3516 } 3517 if (isBuiltInTag(name) || config.isReservedTag(name)) { 3518 warn( 3519 'Do not use built-in or reserved HTML elements as component ' + 3520 'id: ' + name 3521 ); 3522 } 3523} 3524 3525/** 3526 * Ensure all props option syntax are normalized into the 3527 * Object-based format. 3528 */ 3529function normalizeProps (options, vm) { 3530 var props = options.props; 3531 if (!props) { return } 3532 var res = {}; 3533 var i, val, name; 3534 if (Array.isArray(props)) { 3535 i = props.length; 3536 while (i--) { 3537 val = props[i]; 3538 if (typeof val === 'string') { 3539 name = camelize(val); 3540 res[name] = { type: null }; 3541 } else { 3542 warn('props must be strings when using array syntax.'); 3543 } 3544 } 3545 } else if (isPlainObject(props)) { 3546 for (var key in props) { 3547 val = props[key]; 3548 name = camelize(key); 3549 res[name] = isPlainObject(val) 3550 ? val 3551 : { type: val }; 3552 } 3553 } else { 3554 warn( 3555 "Invalid value for option \"props\": expected an Array or an Object, " + 3556 "but got " + (toRawType(props)) + ".", 3557 vm 3558 ); 3559 } 3560 options.props = res; 3561} 3562 3563/** 3564 * Normalize all injections into Object-based format 3565 */ 3566function normalizeInject (options, vm) { 3567 var inject = options.inject; 3568 if (!inject) { return } 3569 var normalized = options.inject = {}; 3570 if (Array.isArray(inject)) { 3571 for (var i = 0; i < inject.length; i++) { 3572 normalized[inject[i]] = { from: inject[i] }; 3573 } 3574 } else if (isPlainObject(inject)) { 3575 for (var key in inject) { 3576 var val = inject[key]; 3577 normalized[key] = isPlainObject(val) 3578 ? extend({ from: key }, val) 3579 : { from: val }; 3580 } 3581 } else { 3582 warn( 3583 "Invalid value for option \"inject\": expected an Array or an Object, " + 3584 "but got " + (toRawType(inject)) + ".", 3585 vm 3586 ); 3587 } 3588} 3589 3590/** 3591 * Normalize raw function directives into object format. 3592 */ 3593function normalizeDirectives (options) { 3594 var dirs = options.directives; 3595 if (dirs) { 3596 for (var key in dirs) { 3597 var def$$1 = dirs[key]; 3598 if (typeof def$$1 === 'function') { 3599 dirs[key] = { bind: def$$1, update: def$$1 }; 3600 } 3601 } 3602 } 3603} 3604 3605function assertObjectType (name, value, vm) { 3606 if (!isPlainObject(value)) { 3607 warn( 3608 "Invalid value for option \"" + name + "\": expected an Object, " + 3609 "but got " + (toRawType(value)) + ".", 3610 vm 3611 ); 3612 } 3613} 3614 3615/** 3616 * Merge two option objects into a new one. 3617 * Core utility used in both instantiation and inheritance. 3618 */ 3619function mergeOptions ( 3620 parent, 3621 child, 3622 vm 3623) { 3624 { 3625 checkComponents(child); 3626 } 3627 3628 if (typeof child === 'function') { 3629 child = child.options; 3630 } 3631 3632 normalizeProps(child, vm); 3633 normalizeInject(child, vm); 3634 normalizeDirectives(child); 3635 3636 // Apply extends and mixins on the child options, 3637 // but only if it is a raw options object that isn't 3638 // the result of another mergeOptions call. 3639 // Only merged options has the _base property. 3640 if (!child._base) { 3641 if (child.extends) { 3642 parent = mergeOptions(parent, child.extends, vm); 3643 } 3644 if (child.mixins) { 3645 for (var i = 0, l = child.mixins.length; i < l; i++) { 3646 parent = mergeOptions(parent, child.mixins[i], vm); 3647 } 3648 } 3649 } 3650 3651 var options = {}; 3652 var key; 3653 for (key in parent) { 3654 mergeField(key); 3655 } 3656 for (key in child) { 3657 if (!hasOwn(parent, key)) { 3658 mergeField(key); 3659 } 3660 } 3661 function mergeField (key) { 3662 var strat = strats[key] || defaultStrat; 3663 options[key] = strat(parent[key], child[key], vm, key); 3664 } 3665 return options 3666} 3667 3668/** 3669 * Resolve an asset. 3670 * This function is used because child instances need access 3671 * to assets defined in its ancestor chain. 3672 */ 3673function resolveAsset ( 3674 options, 3675 type, 3676 id, 3677 warnMissing 3678) { 3679 /* istanbul ignore if */ 3680 if (typeof id !== 'string') { 3681 return 3682 } 3683 var assets = options[type]; 3684 // check local registration variations first 3685 if (hasOwn(assets, id)) { return assets[id] } 3686 var camelizedId = camelize(id); 3687 if (hasOwn(assets, camelizedId)) { return assets[camelizedId] } 3688 var PascalCaseId = capitalize(camelizedId); 3689 if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] } 3690 // fallback to prototype chain 3691 var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; 3692 if (warnMissing && !res) { 3693 warn( 3694 'Failed to resolve ' + type.slice(0, -1) + ': ' + id, 3695 options 3696 ); 3697 } 3698 return res 3699} 3700 3701/* */ 3702 3703 3704 3705function validateProp ( 3706 key, 3707 propOptions, 3708 propsData, 3709 vm 3710) { 3711 var prop = propOptions[key]; 3712 var absent = !hasOwn(propsData, key); 3713 var value = propsData[key]; 3714 // boolean casting 3715 var booleanIndex = getTypeIndex(Boolean, prop.type); 3716 if (booleanIndex > -1) { 3717 if (absent && !hasOwn(prop, 'default')) { 3718 value = false; 3719 } else if (value === '' || value === hyphenate(key)) { 3720 // only cast empty string / same name to boolean if 3721 // boolean has higher priority 3722 var stringIndex = getTypeIndex(String, prop.type); 3723 if (stringIndex < 0 || booleanIndex < stringIndex) { 3724 value = true; 3725 } 3726 } 3727 } 3728 // check default value 3729 if (value === undefined) { 3730 value = getPropDefaultValue(vm, prop, key); 3731 // since the default value is a fresh copy, 3732 // make sure to observe it. 3733 var prevShouldObserve = shouldObserve; 3734 toggleObserving(true); 3735 observe(value); 3736 toggleObserving(prevShouldObserve); 3737 } 3738 { 3739 assertProp(prop, key, value, vm, absent); 3740 } 3741 return value 3742} 3743 3744/** 3745 * Get the default value of a prop. 3746 */ 3747function getPropDefaultValue (vm, prop, key) { 3748 // no default, return undefined 3749 if (!hasOwn(prop, 'default')) { 3750 return undefined 3751 } 3752 var def = prop.default; 3753 // warn against non-factory defaults for Object & Array 3754 if (isObject(def)) { 3755 warn( 3756 'Invalid default value for prop "' + key + '": ' + 3757 'Props with type Object/Array must use a factory function ' + 3758 'to return the default value.', 3759 vm 3760 ); 3761 } 3762 // the raw prop value was also undefined from previous render, 3763 // return previous default value to avoid unnecessary watcher trigger 3764 if (vm && vm.$options.propsData && 3765 vm.$options.propsData[key] === undefined && 3766 vm._props[key] !== undefined 3767 ) { 3768 return vm._props[key] 3769 } 3770 // call factory function for non-Function types 3771 // a value is Function if its prototype is function even across different execution context 3772 return typeof def === 'function' && getType(prop.type) !== 'Function' 3773 ? def.call(vm) 3774 : def 3775} 3776 3777/** 3778 * Assert whether a prop is valid. 3779 */ 3780function assertProp ( 3781 prop, 3782 name, 3783 value, 3784 vm, 3785 absent 3786) { 3787 if (prop.required && absent) { 3788 warn( 3789 'Missing required prop: "' + name + '"', 3790 vm 3791 ); 3792 return 3793 } 3794 if (value == null && !prop.required) { 3795 return 3796 } 3797 var type = prop.type; 3798 var valid = !type || type === true; 3799 var expectedTypes = []; 3800 if (type) { 3801 if (!Array.isArray(type)) { 3802 type = [type]; 3803 } 3804 for (var i = 0; i < type.length && !valid; i++) { 3805 var assertedType = assertType(value, type[i], vm); 3806 expectedTypes.push(assertedType.expectedType || ''); 3807 valid = assertedType.valid; 3808 } 3809 } 3810 3811 var haveExpectedTypes = expectedTypes.some(function (t) { return t; }); 3812 if (!valid && haveExpectedTypes) { 3813 warn( 3814 getInvalidTypeMessage(name, value, expectedTypes), 3815 vm 3816 ); 3817 return 3818 } 3819 var validator = prop.validator; 3820 if (validator) { 3821 if (!validator(value)) { 3822 warn( 3823 'Invalid prop: custom validator check failed for prop "' + name + '".', 3824 vm 3825 ); 3826 } 3827 } 3828} 3829 3830var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/; 3831 3832function assertType (value, type, vm) { 3833 var valid; 3834 var expectedType = getType(type); 3835 if (simpleCheckRE.test(expectedType)) { 3836 var t = typeof value; 3837 valid = t === expectedType.toLowerCase(); 3838 // for primitive wrapper objects 3839 if (!valid && t === 'object') { 3840 valid = value instanceof type; 3841 } 3842 } else if (expectedType === 'Object') { 3843 valid = isPlainObject(value); 3844 } else if (expectedType === 'Array') { 3845 valid = Array.isArray(value); 3846 } else { 3847 try { 3848 valid = value instanceof type; 3849 } catch (e) { 3850 warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm); 3851 valid = false; 3852 } 3853 } 3854 return { 3855 valid: valid, 3856 expectedType: expectedType 3857 } 3858} 3859 3860var functionTypeCheckRE = /^\s*function (\w+)/; 3861 3862/** 3863 * Use function string name to check built-in types, 3864 * because a simple equality check will fail when running 3865 * across different vms / iframes. 3866 */ 3867function getType (fn) { 3868 var match = fn && fn.toString().match(functionTypeCheckRE); 3869 return match ? match[1] : '' 3870} 3871 3872function isSameType (a, b) { 3873 return getType(a) === getType(b) 3874} 3875 3876function getTypeIndex (type, expectedTypes) { 3877 if (!Array.isArray(expectedTypes)) { 3878 return isSameType(expectedTypes, type) ? 0 : -1 3879 } 3880 for (var i = 0, len = expectedTypes.length; i < len; i++) { 3881 if (isSameType(expectedTypes[i], type)) { 3882 return i 3883 } 3884 } 3885 return -1 3886} 3887 3888function getInvalidTypeMessage (name, value, expectedTypes) { 3889 var message = "Invalid prop: type check failed for prop \"" + name + "\"." + 3890 " Expected " + (expectedTypes.map(capitalize).join(', ')); 3891 var expectedType = expectedTypes[0]; 3892 var receivedType = toRawType(value); 3893 // check if we need to specify expected value 3894 if ( 3895 expectedTypes.length === 1 && 3896 isExplicable(expectedType) && 3897 isExplicable(typeof value) && 3898 !isBoolean(expectedType, receivedType) 3899 ) { 3900 message += " with value " + (styleValue(value, expectedType)); 3901 } 3902 message += ", got " + receivedType + " "; 3903 // check if we need to specify received value 3904 if (isExplicable(receivedType)) { 3905 message += "with value " + (styleValue(value, receivedType)) + "."; 3906 } 3907 return message 3908} 3909 3910function styleValue (value, type) { 3911 if (type === 'String') { 3912 return ("\"" + value + "\"") 3913 } else if (type === 'Number') { 3914 return ("" + (Number(value))) 3915 } else { 3916 return ("" + value) 3917 } 3918} 3919 3920var EXPLICABLE_TYPES = ['string', 'number', 'boolean']; 3921function isExplicable (value) { 3922 return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; }) 3923} 3924 3925function isBoolean () { 3926 var args = [], len = arguments.length; 3927 while ( len-- ) args[ len ] = arguments[ len ]; 3928 3929 return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; }) 3930} 3931 3932/* */ 3933 3934function handleError (err, vm, info) { 3935 // Deactivate deps tracking while processing error handler to avoid possible infinite rendering. 3936 // See: https://github.com/vuejs/vuex/issues/1505 3937 pushTarget(); 3938 try { 3939 if (vm) { 3940 var cur = vm; 3941 while ((cur = cur.$parent)) { 3942 var hooks = cur.$options.errorCaptured; 3943 if (hooks) { 3944 for (var i = 0; i < hooks.length; i++) { 3945 try { 3946 var capture = hooks[i].call(cur, err, vm, info) === false; 3947 if (capture) { return } 3948 } catch (e) { 3949 globalHandleError(e, cur, 'errorCaptured hook'); 3950 } 3951 } 3952 } 3953 } 3954 } 3955 globalHandleError(err, vm, info); 3956 } finally { 3957 popTarget(); 3958 } 3959} 3960 3961function invokeWithErrorHandling ( 3962 handler, 3963 context, 3964 args, 3965 vm, 3966 info 3967) { 3968 var res; 3969 try { 3970 res = args ? handler.apply(context, args) : handler.call(context); 3971 if (res && !res._isVue && isPromise(res) && !res._handled) { 3972 res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); }); 3973 // issue #9511 3974 // avoid catch triggering multiple times when nested calls 3975 res._handled = true; 3976 } 3977 } catch (e) { 3978 handleError(e, vm, info); 3979 } 3980 return res 3981} 3982 3983function globalHandleError (err, vm, info) { 3984 if (config.errorHandler) { 3985 try { 3986 return config.errorHandler.call(null, err, vm, info) 3987 } catch (e) { 3988 // if the user intentionally throws the original error in the handler, 3989 // do not log it twice 3990 if (e !== err) { 3991 logError(e, null, 'config.errorHandler'); 3992 } 3993 } 3994 } 3995 logError(err, vm, info); 3996} 3997 3998function logError (err, vm, info) { 3999 { 4000 warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm); 4001 } 4002 /* istanbul ignore else */ 4003 if ((inBrowser || inWeex) && typeof console !== 'undefined') { 4004 console.error(err); 4005 } else { 4006 throw err 4007 } 4008} 4009 4010/* */ 4011 4012var isUsingMicroTask = false; 4013 4014var callbacks = []; 4015var pending = false; 4016 4017function flushCallbacks () { 4018 pending = false; 4019 var copies = callbacks.slice(0); 4020 callbacks.length = 0; 4021 for (var i = 0; i < copies.length; i++) { 4022 copies[i](); 4023 } 4024} 4025 4026// Here we have async deferring wrappers using microtasks. 4027// In 2.5 we used (macro) tasks (in combination with microtasks). 4028// However, it has subtle problems when state is changed right before repaint 4029// (e.g. #6813, out-in transitions). 4030// Also, using (macro) tasks in event handler would cause some weird behaviors 4031// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109). 4032// So we now use microtasks everywhere, again. 4033// A major drawback of this tradeoff is that there are some scenarios 4034// where microtasks have too high a priority and fire in between supposedly 4035// sequential events (e.g. #4521, #6690, which have workarounds) 4036// or even between bubbling of the same event (#6566). 4037var timerFunc; 4038 4039// The nextTick behavior leverages the microtask queue, which can be accessed 4040// via either native Promise.then or MutationObserver. 4041// MutationObserver has wider support, however it is seriously bugged in 4042// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It 4043// completely stops working after triggering a few times... so, if native 4044// Promise is available, we will use it: 4045/* istanbul ignore next, $flow-disable-line */ 4046if (typeof Promise !== 'undefined' && isNative(Promise)) { 4047 var p = Promise.resolve(); 4048 timerFunc = function () { 4049 p.then(flushCallbacks); 4050 // In problematic UIWebViews, Promise.then doesn't completely break, but 4051 // it can get stuck in a weird state where callbacks are pushed into the 4052 // microtask queue but the queue isn't being flushed, until the browser 4053 // needs to do some other work, e.g. handle a timer. Therefore we can 4054 // "force" the microtask queue to be flushed by adding an empty timer. 4055 if (isIOS) { setTimeout(noop); } 4056 }; 4057 isUsingMicroTask = true; 4058} else if (!isIE && typeof MutationObserver !== 'undefined' && ( 4059 isNative(MutationObserver) || 4060 // PhantomJS and iOS 7.x 4061 MutationObserver.toString() === '[object MutationObserverConstructor]' 4062)) { 4063 // Use MutationObserver where native Promise is not available, 4064 // e.g. PhantomJS, iOS7, Android 4.4 4065 // (#6466 MutationObserver is unreliable in IE11) 4066 var counter = 1; 4067 var observer = new MutationObserver(flushCallbacks); 4068 var textNode = document.createTextNode(String(counter)); 4069 observer.observe(textNode, { 4070 characterData: true 4071 }); 4072 timerFunc = function () { 4073 counter = (counter + 1) % 2; 4074 textNode.data = String(counter); 4075 }; 4076 isUsingMicroTask = true; 4077} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) { 4078 // Fallback to setImmediate. 4079 // Technically it leverages the (macro) task queue, 4080 // but it is still a better choice than setTimeout. 4081 timerFunc = function () { 4082 setImmediate(flushCallbacks); 4083 }; 4084} else { 4085 // Fallback to setTimeout. 4086 timerFunc = function () { 4087 setTimeout(flushCallbacks, 0); 4088 }; 4089} 4090 4091function nextTick (cb, ctx) { 4092 var _resolve; 4093 callbacks.push(function () { 4094 if (cb) { 4095 try { 4096 cb.call(ctx); 4097 } catch (e) { 4098 handleError(e, ctx, 'nextTick'); 4099 } 4100 } else if (_resolve) { 4101 _resolve(ctx); 4102 } 4103 }); 4104 if (!pending) { 4105 pending = true; 4106 timerFunc(); 4107 } 4108 // $flow-disable-line 4109 if (!cb && typeof Promise !== 'undefined') { 4110 return new Promise(function (resolve) { 4111 _resolve = resolve; 4112 }) 4113 } 4114} 4115 4116/* */ 4117 4118var mark; 4119var measure; 4120 4121{ 4122 var perf = inBrowser && window.performance; 4123 /* istanbul ignore if */ 4124 if ( 4125 perf && 4126 perf.mark && 4127 perf.measure && 4128 perf.clearMarks && 4129 perf.clearMeasures 4130 ) { 4131 mark = function (tag) { return perf.mark(tag); }; 4132 measure = function (name, startTag, endTag) { 4133 perf.measure(name, startTag, endTag); 4134 perf.clearMarks(startTag); 4135 perf.clearMarks(endTag); 4136 // perf.clearMeasures(name) 4137 }; 4138 } 4139} 4140 4141/* not type checking this file because flow doesn't play well with Proxy */ 4142 4143var initProxy; 4144 4145{ 4146 var allowedGlobals = makeMap( 4147 'Infinity,undefined,NaN,isFinite,isNaN,' + 4148 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 4149 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' + 4150 'require' // for Webpack/Browserify 4151 ); 4152 4153 var warnNonPresent = function (target, key) { 4154 warn( 4155 "Property or method \"" + key + "\" is not defined on the instance but " + 4156 'referenced during render. Make sure that this property is reactive, ' + 4157 'either in the data option, or for class-based components, by ' + 4158 'initializing the property. ' + 4159 'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', 4160 target 4161 ); 4162 }; 4163 4164 var warnReservedPrefix = function (target, key) { 4165 warn( 4166 "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " + 4167 'properties starting with "$" or "_" are not proxied in the Vue instance to ' + 4168 'prevent conflicts with Vue internals. ' + 4169 'See: https://vuejs.org/v2/api/#data', 4170 target 4171 ); 4172 }; 4173 4174 var hasProxy = 4175 typeof Proxy !== 'undefined' && isNative(Proxy); 4176 4177 if (hasProxy) { 4178 var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); 4179 config.keyCodes = new Proxy(config.keyCodes, { 4180 set: function set (target, key, value) { 4181 if (isBuiltInModifier(key)) { 4182 warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key)); 4183 return false 4184 } else { 4185 target[key] = value; 4186 return true 4187 } 4188 } 4189 }); 4190 } 4191 4192 var hasHandler = { 4193 has: function has (target, key) { 4194 var has = key in target; 4195 var isAllowed = allowedGlobals(key) || 4196 (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data)); 4197 if (!has && !isAllowed) { 4198 if (key in target.$data) { warnReservedPrefix(target, key); } 4199 else { warnNonPresent(target, key); } 4200 } 4201 return has || !isAllowed 4202 } 4203 }; 4204 4205 var getHandler = { 4206 get: function get (target, key) { 4207 if (typeof key === 'string' && !(key in target)) { 4208 if (key in target.$data) { warnReservedPrefix(target, key); } 4209 else { warnNonPresent(target, key); } 4210 } 4211 return target[key] 4212 } 4213 }; 4214 4215 initProxy = function initProxy (vm) { 4216 if (hasProxy) { 4217 // determine which proxy handler to use 4218 var options = vm.$options; 4219 var handlers = options.render && options.render._withStripped 4220 ? getHandler 4221 : hasHandler; 4222 vm._renderProxy = new Proxy(vm, handlers); 4223 } else { 4224 vm._renderProxy = vm; 4225 } 4226 }; 4227} 4228 4229/* */ 4230 4231var seenObjects = new _Set(); 4232 4233/** 4234 * Recursively traverse an object to evoke all converted 4235 * getters, so that every nested property inside the object 4236 * is collected as a "deep" dependency. 4237 */ 4238function traverse (val) { 4239 _traverse(val, seenObjects); 4240 seenObjects.clear(); 4241} 4242 4243function _traverse (val, seen) { 4244 var i, keys; 4245 var isA = Array.isArray(val); 4246 if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) { 4247 return 4248 } 4249 if (val.__ob__) { 4250 var depId = val.__ob__.dep.id; 4251 if (seen.has(depId)) { 4252 return 4253 } 4254 seen.add(depId); 4255 } 4256 if (isA) { 4257 i = val.length; 4258 while (i--) { _traverse(val[i], seen); } 4259 } else { 4260 keys = Object.keys(val); 4261 i = keys.length; 4262 while (i--) { _traverse(val[keys[i]], seen); } 4263 } 4264} 4265 4266/* */ 4267 4268var normalizeEvent = cached(function (name) { 4269 var passive = name.charAt(0) === '&'; 4270 name = passive ? name.slice(1) : name; 4271 var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first 4272 name = once$$1 ? name.slice(1) : name; 4273 var capture = name.charAt(0) === '!'; 4274 name = capture ? name.slice(1) : name; 4275 return { 4276 name: name, 4277 once: once$$1, 4278 capture: capture, 4279 passive: passive 4280 } 4281}); 4282 4283function createFnInvoker (fns, vm) { 4284 function invoker () { 4285 var arguments$1 = arguments; 4286 4287 var fns = invoker.fns; 4288 if (Array.isArray(fns)) { 4289 var cloned = fns.slice(); 4290 for (var i = 0; i < cloned.length; i++) { 4291 invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler"); 4292 } 4293 } else { 4294 // return handler return value for single handlers 4295 return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler") 4296 } 4297 } 4298 invoker.fns = fns; 4299 return invoker 4300} 4301 4302function updateListeners ( 4303 on, 4304 oldOn, 4305 add, 4306 remove$$1, 4307 createOnceHandler, 4308 vm 4309) { 4310 var name, def$$1, cur, old, event; 4311 for (name in on) { 4312 def$$1 = cur = on[name]; 4313 old = oldOn[name]; 4314 event = normalizeEvent(name); 4315 if (isUndef(cur)) { 4316 warn( 4317 "Invalid handler for event \"" + (event.name) + "\": got " + String(cur), 4318 vm 4319 ); 4320 } else if (isUndef(old)) { 4321 if (isUndef(cur.fns)) { 4322 cur = on[name] = createFnInvoker(cur, vm); 4323 } 4324 if (isTrue(event.once)) { 4325 cur = on[name] = createOnceHandler(event.name, cur, event.capture); 4326 } 4327 add(event.name, cur, event.capture, event.passive, event.params); 4328 } else if (cur !== old) { 4329 old.fns = cur; 4330 on[name] = old; 4331 } 4332 } 4333 for (name in oldOn) { 4334 if (isUndef(on[name])) { 4335 event = normalizeEvent(name); 4336 remove$$1(event.name, oldOn[name], event.capture); 4337 } 4338 } 4339} 4340 4341/* */ 4342 4343function mergeVNodeHook (def, hookKey, hook) { 4344 if (def instanceof VNode) { 4345 def = def.data.hook || (def.data.hook = {}); 4346 } 4347 var invoker; 4348 var oldHook = def[hookKey]; 4349 4350 function wrappedHook () { 4351 hook.apply(this, arguments); 4352 // important: remove merged hook to ensure it's called only once 4353 // and prevent memory leak 4354 remove(invoker.fns, wrappedHook); 4355 } 4356 4357 if (isUndef(oldHook)) { 4358 // no existing hook 4359 invoker = createFnInvoker([wrappedHook]); 4360 } else { 4361 /* istanbul ignore if */ 4362 if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { 4363 // already a merged invoker 4364 invoker = oldHook; 4365 invoker.fns.push(wrappedHook); 4366 } else { 4367 // existing plain hook 4368 invoker = createFnInvoker([oldHook, wrappedHook]); 4369 } 4370 } 4371 4372 invoker.merged = true; 4373 def[hookKey] = invoker; 4374} 4375 4376/* */ 4377 4378function extractPropsFromVNodeData ( 4379 data, 4380 Ctor, 4381 tag 4382) { 4383 // we are only extracting raw values here. 4384 // validation and default values are handled in the child 4385 // component itself. 4386 var propOptions = Ctor.options.props; 4387 if (isUndef(propOptions)) { 4388 return 4389 } 4390 var res = {}; 4391 var attrs = data.attrs; 4392 var props = data.props; 4393 if (isDef(attrs) || isDef(props)) { 4394 for (var key in propOptions) { 4395 var altKey = hyphenate(key); 4396 { 4397 var keyInLowerCase = key.toLowerCase(); 4398 if ( 4399 key !== keyInLowerCase && 4400 attrs && hasOwn(attrs, keyInLowerCase) 4401 ) { 4402 tip( 4403 "Prop \"" + keyInLowerCase + "\" is passed to component " + 4404 (formatComponentName(tag || Ctor)) + ", but the declared prop name is" + 4405 " \"" + key + "\". " + 4406 "Note that HTML attributes are case-insensitive and camelCased " + 4407 "props need to use their kebab-case equivalents when using in-DOM " + 4408 "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"." 4409 ); 4410 } 4411 } 4412 checkProp(res, props, key, altKey, true) || 4413 checkProp(res, attrs, key, altKey, false); 4414 } 4415 } 4416 return res 4417} 4418 4419function checkProp ( 4420 res, 4421 hash, 4422 key, 4423 altKey, 4424 preserve 4425) { 4426 if (isDef(hash)) { 4427 if (hasOwn(hash, key)) { 4428 res[key] = hash[key]; 4429 if (!preserve) { 4430 delete hash[key]; 4431 } 4432 return true 4433 } else if (hasOwn(hash, altKey)) { 4434 res[key] = hash[altKey]; 4435 if (!preserve) { 4436 delete hash[altKey]; 4437 } 4438 return true 4439 } 4440 } 4441 return false 4442} 4443 4444/* */ 4445 4446// The template compiler attempts to minimize the need for normalization by 4447// statically analyzing the template at compile time. 4448// 4449// For plain HTML markup, normalization can be completely skipped because the 4450// generated render function is guaranteed to return Array<VNode>. There are 4451// two cases where extra normalization is needed: 4452 4453// 1. When the children contains components - because a functional component 4454// may return an Array instead of a single root. In this case, just a simple 4455// normalization is needed - if any child is an Array, we flatten the whole 4456// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 4457// because functional components already normalize their own children. 4458function simpleNormalizeChildren (children) { 4459 for (var i = 0; i < children.length; i++) { 4460 if (Array.isArray(children[i])) { 4461 return Array.prototype.concat.apply([], children) 4462 } 4463 } 4464 return children 4465} 4466 4467// 2. When the children contains constructs that always generated nested Arrays, 4468// e.g. <template>, <slot>, v-for, or when the children is provided by user 4469// with hand-written render functions / JSX. In such cases a full normalization 4470// is needed to cater to all possible types of children values. 4471function normalizeChildren (children) { 4472 return isPrimitive(children) 4473 ? [createTextVNode(children)] 4474 : Array.isArray(children) 4475 ? normalizeArrayChildren(children) 4476 : undefined 4477} 4478 4479function isTextNode (node) { 4480 return isDef(node) && isDef(node.text) && isFalse(node.isComment) 4481} 4482 4483function normalizeArrayChildren (children, nestedIndex) { 4484 var res = []; 4485 var i, c, lastIndex, last; 4486 for (i = 0; i < children.length; i++) { 4487 c = children[i]; 4488 if (isUndef(c) || typeof c === 'boolean') { continue } 4489 lastIndex = res.length - 1; 4490 last = res[lastIndex]; 4491 // nested 4492 if (Array.isArray(c)) { 4493 if (c.length > 0) { 4494 c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)); 4495 // merge adjacent text nodes 4496 if (isTextNode(c[0]) && isTextNode(last)) { 4497 res[lastIndex] = createTextVNode(last.text + (c[0]).text); 4498 c.shift(); 4499 } 4500 res.push.apply(res, c); 4501 } 4502 } else if (isPrimitive(c)) { 4503 if (isTextNode(last)) { 4504 // merge adjacent text nodes 4505 // this is necessary for SSR hydration because text nodes are 4506 // essentially merged when rendered to HTML strings 4507 res[lastIndex] = createTextVNode(last.text + c); 4508 } else if (c !== '') { 4509 // convert primitive to vnode 4510 res.push(createTextVNode(c)); 4511 } 4512 } else { 4513 if (isTextNode(c) && isTextNode(last)) { 4514 // merge adjacent text nodes 4515 res[lastIndex] = createTextVNode(last.text + c.text); 4516 } else { 4517 // default key for nested array children (likely generated by v-for) 4518 if (isTrue(children._isVList) && 4519 isDef(c.tag) && 4520 isUndef(c.key) && 4521 isDef(nestedIndex)) { 4522 c.key = "__vlist" + nestedIndex + "_" + i + "__"; 4523 } 4524 res.push(c); 4525 } 4526 } 4527 } 4528 return res 4529} 4530 4531/* */ 4532 4533function initProvide (vm) { 4534 var provide = vm.$options.provide; 4535 if (provide) { 4536 vm._provided = typeof provide === 'function' 4537 ? provide.call(vm) 4538 : provide; 4539 } 4540} 4541 4542function initInjections (vm) { 4543 var result = resolveInject(vm.$options.inject, vm); 4544 if (result) { 4545 toggleObserving(false); 4546 Object.keys(result).forEach(function (key) { 4547 /* istanbul ignore else */ 4548 { 4549 defineReactive$$1(vm, key, result[key], function () { 4550 warn( 4551 "Avoid mutating an injected value directly since the changes will be " + 4552 "overwritten whenever the provided component re-renders. " + 4553 "injection being mutated: \"" + key + "\"", 4554 vm 4555 ); 4556 }); 4557 } 4558 }); 4559 toggleObserving(true); 4560 } 4561} 4562 4563function resolveInject (inject, vm) { 4564 if (inject) { 4565 // inject is :any because flow is not smart enough to figure out cached 4566 var result = Object.create(null); 4567 var keys = hasSymbol 4568 ? Reflect.ownKeys(inject) 4569 : Object.keys(inject); 4570 4571 for (var i = 0; i < keys.length; i++) { 4572 var key = keys[i]; 4573 // #6574 in case the inject object is observed... 4574 if (key === '__ob__') { continue } 4575 var provideKey = inject[key].from; 4576 var source = vm; 4577 while (source) { 4578 if (source._provided && hasOwn(source._provided, provideKey)) { 4579 result[key] = source._provided[provideKey]; 4580 break 4581 } 4582 source = source.$parent; 4583 } 4584 if (!source) { 4585 if ('default' in inject[key]) { 4586 var provideDefault = inject[key].default; 4587 result[key] = typeof provideDefault === 'function' 4588 ? provideDefault.call(vm) 4589 : provideDefault; 4590 } else { 4591 warn(("Injection \"" + key + "\" not found"), vm); 4592 } 4593 } 4594 } 4595 return result 4596 } 4597} 4598 4599/* */ 4600 4601 4602 4603/** 4604 * Runtime helper for resolving raw children VNodes into a slot object. 4605 */ 4606function resolveSlots ( 4607 children, 4608 context 4609) { 4610 if (!children || !children.length) { 4611 return {} 4612 } 4613 var slots = {}; 4614 for (var i = 0, l = children.length; i < l; i++) { 4615 var child = children[i]; 4616 var data = child.data; 4617 // remove slot attribute if the node is resolved as a Vue slot node 4618 if (data && data.attrs && data.attrs.slot) { 4619 delete data.attrs.slot; 4620 } 4621 // named slots should only be respected if the vnode was rendered in the 4622 // same context. 4623 if ((child.context === context || child.fnContext === context) && 4624 data && data.slot != null 4625 ) { 4626 var name = data.slot; 4627 var slot = (slots[name] || (slots[name] = [])); 4628 if (child.tag === 'template') { 4629 slot.push.apply(slot, child.children || []); 4630 } else { 4631 slot.push(child); 4632 } 4633 } else { 4634 (slots.default || (slots.default = [])).push(child); 4635 } 4636 } 4637 // ignore slots that contains only whitespace 4638 for (var name$1 in slots) { 4639 if (slots[name$1].every(isWhitespace)) { 4640 delete slots[name$1]; 4641 } 4642 } 4643 return slots 4644} 4645 4646function isWhitespace (node) { 4647 return (node.isComment && !node.asyncFactory) || node.text === ' ' 4648} 4649 4650/* */ 4651 4652function isAsyncPlaceholder (node) { 4653 return node.isComment && node.asyncFactory 4654} 4655 4656/* */ 4657 4658function normalizeScopedSlots ( 4659 slots, 4660 normalSlots, 4661 prevSlots 4662) { 4663 var res; 4664 var hasNormalSlots = Object.keys(normalSlots).length > 0; 4665 var isStable = slots ? !!slots.$stable : !hasNormalSlots; 4666 var key = slots && slots.$key; 4667 if (!slots) { 4668 res = {}; 4669 } else if (slots._normalized) { 4670 // fast path 1: child component re-render only, parent did not change 4671 return slots._normalized 4672 } else if ( 4673 isStable && 4674 prevSlots && 4675 prevSlots !== emptyObject && 4676 key === prevSlots.$key && 4677 !hasNormalSlots && 4678 !prevSlots.$hasNormal 4679 ) { 4680 // fast path 2: stable scoped slots w/ no normal slots to proxy, 4681 // only need to normalize once 4682 return prevSlots 4683 } else { 4684 res = {}; 4685 for (var key$1 in slots) { 4686 if (slots[key$1] && key$1[0] !== '$') { 4687 res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]); 4688 } 4689 } 4690 } 4691 // expose normal slots on scopedSlots 4692 for (var key$2 in normalSlots) { 4693 if (!(key$2 in res)) { 4694 res[key$2] = proxyNormalSlot(normalSlots, key$2); 4695 } 4696 } 4697 // avoriaz seems to mock a non-extensible $scopedSlots object 4698 // and when that is passed down this would cause an error 4699 if (slots && Object.isExtensible(slots)) { 4700 (slots)._normalized = res; 4701 } 4702 def(res, '$stable', isStable); 4703 def(res, '$key', key); 4704 def(res, '$hasNormal', hasNormalSlots); 4705 return res 4706} 4707 4708function normalizeScopedSlot(normalSlots, key, fn) { 4709 var normalized = function () { 4710 var res = arguments.length ? fn.apply(null, arguments) : fn({}); 4711 res = res && typeof res === 'object' && !Array.isArray(res) 4712 ? [res] // single vnode 4713 : normalizeChildren(res); 4714 var vnode = res && res[0]; 4715 return res && ( 4716 !vnode || 4717 (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode)) // #9658, #10391 4718 ) ? undefined 4719 : res 4720 }; 4721 // this is a slot using the new v-slot syntax without scope. although it is 4722 // compiled as a scoped slot, render fn users would expect it to be present 4723 // on this.$slots because the usage is semantically a normal slot. 4724 if (fn.proxy) { 4725 Object.defineProperty(normalSlots, key, { 4726 get: normalized, 4727 enumerable: true, 4728 configurable: true 4729 }); 4730 } 4731 return normalized 4732} 4733 4734function proxyNormalSlot(slots, key) { 4735 return function () { return slots[key]; } 4736} 4737 4738/* */ 4739 4740/** 4741 * Runtime helper for rendering v-for lists. 4742 */ 4743function renderList ( 4744 val, 4745 render 4746) { 4747 var ret, i, l, keys, key; 4748 if (Array.isArray(val) || typeof val === 'string') { 4749 ret = new Array(val.length); 4750 for (i = 0, l = val.length; i < l; i++) { 4751 ret[i] = render(val[i], i); 4752 } 4753 } else if (typeof val === 'number') { 4754 ret = new Array(val); 4755 for (i = 0; i < val; i++) { 4756 ret[i] = render(i + 1, i); 4757 } 4758 } else if (isObject(val)) { 4759 if (hasSymbol && val[Symbol.iterator]) { 4760 ret = []; 4761 var iterator = val[Symbol.iterator](); 4762 var result = iterator.next(); 4763 while (!result.done) { 4764 ret.push(render(result.value, ret.length)); 4765 result = iterator.next(); 4766 } 4767 } else { 4768 keys = Object.keys(val); 4769 ret = new Array(keys.length); 4770 for (i = 0, l = keys.length; i < l; i++) { 4771 key = keys[i]; 4772 ret[i] = render(val[key], key, i); 4773 } 4774 } 4775 } 4776 if (!isDef(ret)) { 4777 ret = []; 4778 } 4779 (ret)._isVList = true; 4780 return ret 4781} 4782 4783/* */ 4784 4785/** 4786 * Runtime helper for rendering <slot> 4787 */ 4788function renderSlot ( 4789 name, 4790 fallbackRender, 4791 props, 4792 bindObject 4793) { 4794 var scopedSlotFn = this.$scopedSlots[name]; 4795 var nodes; 4796 if (scopedSlotFn) { 4797 // scoped slot 4798 props = props || {}; 4799 if (bindObject) { 4800 if (!isObject(bindObject)) { 4801 warn('slot v-bind without argument expects an Object', this); 4802 } 4803 props = extend(extend({}, bindObject), props); 4804 } 4805 nodes = 4806 scopedSlotFn(props) || 4807 (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender); 4808 } else { 4809 nodes = 4810 this.$slots[name] || 4811 (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender); 4812 } 4813 4814 var target = props && props.slot; 4815 if (target) { 4816 return this.$createElement('template', { slot: target }, nodes) 4817 } else { 4818 return nodes 4819 } 4820} 4821 4822/* */ 4823 4824/** 4825 * Runtime helper for resolving filters 4826 */ 4827function resolveFilter (id) { 4828 return resolveAsset(this.$options, 'filters', id, true) || identity 4829} 4830 4831/* */ 4832 4833function isKeyNotMatch (expect, actual) { 4834 if (Array.isArray(expect)) { 4835 return expect.indexOf(actual) === -1 4836 } else { 4837 return expect !== actual 4838 } 4839} 4840 4841/** 4842 * Runtime helper for checking keyCodes from config. 4843 * exposed as Vue.prototype._k 4844 * passing in eventKeyName as last argument separately for backwards compat 4845 */ 4846function checkKeyCodes ( 4847 eventKeyCode, 4848 key, 4849 builtInKeyCode, 4850 eventKeyName, 4851 builtInKeyName 4852) { 4853 var mappedKeyCode = config.keyCodes[key] || builtInKeyCode; 4854 if (builtInKeyName && eventKeyName && !config.keyCodes[key]) { 4855 return isKeyNotMatch(builtInKeyName, eventKeyName) 4856 } else if (mappedKeyCode) { 4857 return isKeyNotMatch(mappedKeyCode, eventKeyCode) 4858 } else if (eventKeyName) { 4859 return hyphenate(eventKeyName) !== key 4860 } 4861 return eventKeyCode === undefined 4862} 4863 4864/* */ 4865 4866/** 4867 * Runtime helper for merging v-bind="object" into a VNode's data. 4868 */ 4869function bindObjectProps ( 4870 data, 4871 tag, 4872 value, 4873 asProp, 4874 isSync 4875) { 4876 if (value) { 4877 if (!isObject(value)) { 4878 warn( 4879 'v-bind without argument expects an Object or Array value', 4880 this 4881 ); 4882 } else { 4883 if (Array.isArray(value)) { 4884 value = toObject(value); 4885 } 4886 var hash; 4887 var loop = function ( key ) { 4888 if ( 4889 key === 'class' || 4890 key === 'style' || 4891 isReservedAttribute(key) 4892 ) { 4893 hash = data; 4894 } else { 4895 var type = data.attrs && data.attrs.type; 4896 hash = asProp || config.mustUseProp(tag, type, key) 4897 ? data.domProps || (data.domProps = {}) 4898 : data.attrs || (data.attrs = {}); 4899 } 4900 var camelizedKey = camelize(key); 4901 var hyphenatedKey = hyphenate(key); 4902 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) { 4903 hash[key] = value[key]; 4904 4905 if (isSync) { 4906 var on = data.on || (data.on = {}); 4907 on[("update:" + key)] = function ($event) { 4908 value[key] = $event; 4909 }; 4910 } 4911 } 4912 }; 4913 4914 for (var key in value) loop( key ); 4915 } 4916 } 4917 return data 4918} 4919 4920/* */ 4921 4922/** 4923 * Runtime helper for rendering static trees. 4924 */ 4925function renderStatic ( 4926 index, 4927 isInFor 4928) { 4929 var cached = this._staticTrees || (this._staticTrees = []); 4930 var tree = cached[index]; 4931 // if has already-rendered static tree and not inside v-for, 4932 // we can reuse the same tree. 4933 if (tree && !isInFor) { 4934 return tree 4935 } 4936 // otherwise, render a fresh tree. 4937 tree = cached[index] = this.$options.staticRenderFns[index].call( 4938 this._renderProxy, 4939 null, 4940 this // for render fns generated for functional component templates 4941 ); 4942 markStatic(tree, ("__static__" + index), false); 4943 return tree 4944} 4945 4946/** 4947 * Runtime helper for v-once. 4948 * Effectively it means marking the node as static with a unique key. 4949 */ 4950function markOnce ( 4951 tree, 4952 index, 4953 key 4954) { 4955 markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true); 4956 return tree 4957} 4958 4959function markStatic ( 4960 tree, 4961 key, 4962 isOnce 4963) { 4964 if (Array.isArray(tree)) { 4965 for (var i = 0; i < tree.length; i++) { 4966 if (tree[i] && typeof tree[i] !== 'string') { 4967 markStaticNode(tree[i], (key + "_" + i), isOnce); 4968 } 4969 } 4970 } else { 4971 markStaticNode(tree, key, isOnce); 4972 } 4973} 4974 4975function markStaticNode (node, key, isOnce) { 4976 node.isStatic = true; 4977 node.key = key; 4978 node.isOnce = isOnce; 4979} 4980 4981/* */ 4982 4983function bindObjectListeners (data, value) { 4984 if (value) { 4985 if (!isPlainObject(value)) { 4986 warn( 4987 'v-on without argument expects an Object value', 4988 this 4989 ); 4990 } else { 4991 var on = data.on = data.on ? extend({}, data.on) : {}; 4992 for (var key in value) { 4993 var existing = on[key]; 4994 var ours = value[key]; 4995 on[key] = existing ? [].concat(existing, ours) : ours; 4996 } 4997 } 4998 } 4999 return data 5000} 5001 5002/* */ 5003 5004function resolveScopedSlots ( 5005 fns, // see flow/vnode 5006 res, 5007 // the following are added in 2.6 5008 hasDynamicKeys, 5009 contentHashKey 5010) { 5011 res = res || { $stable: !hasDynamicKeys }; 5012 for (var i = 0; i < fns.length; i++) { 5013 var slot = fns[i]; 5014 if (Array.isArray(slot)) { 5015 resolveScopedSlots(slot, res, hasDynamicKeys); 5016 } else if (slot) { 5017 // marker for reverse proxying v-slot without scope on this.$slots 5018 if (slot.proxy) { 5019 slot.fn.proxy = true; 5020 } 5021 res[slot.key] = slot.fn; 5022 } 5023 } 5024 if (contentHashKey) { 5025 (res).$key = contentHashKey; 5026 } 5027 return res 5028} 5029 5030/* */ 5031 5032function bindDynamicKeys (baseObj, values) { 5033 for (var i = 0; i < values.length; i += 2) { 5034 var key = values[i]; 5035 if (typeof key === 'string' && key) { 5036 baseObj[values[i]] = values[i + 1]; 5037 } else if (key !== '' && key !== null) { 5038 // null is a special value for explicitly removing a binding 5039 warn( 5040 ("Invalid value for dynamic directive argument (expected string or null): " + key), 5041 this 5042 ); 5043 } 5044 } 5045 return baseObj 5046} 5047 5048// helper to dynamically append modifier runtime markers to event names. 5049// ensure only append when value is already string, otherwise it will be cast 5050// to string and cause the type check to miss. 5051function prependModifier (value, symbol) { 5052 return typeof value === 'string' ? symbol + value : value 5053} 5054 5055/* */ 5056 5057function installRenderHelpers (target) { 5058 target._o = markOnce; 5059 target._n = toNumber; 5060 target._s = toString; 5061 target._l = renderList; 5062 target._t = renderSlot; 5063 target._q = looseEqual; 5064 target._i = looseIndexOf; 5065 target._m = renderStatic; 5066 target._f = resolveFilter; 5067 target._k = checkKeyCodes; 5068 target._b = bindObjectProps; 5069 target._v = createTextVNode; 5070 target._e = createEmptyVNode; 5071 target._u = resolveScopedSlots; 5072 target._g = bindObjectListeners; 5073 target._d = bindDynamicKeys; 5074 target._p = prependModifier; 5075} 5076 5077/* */ 5078 5079function FunctionalRenderContext ( 5080 data, 5081 props, 5082 children, 5083 parent, 5084 Ctor 5085) { 5086 var this$1 = this; 5087 5088 var options = Ctor.options; 5089 // ensure the createElement function in functional components 5090 // gets a unique context - this is necessary for correct named slot check 5091 var contextVm; 5092 if (hasOwn(parent, '_uid')) { 5093 contextVm = Object.create(parent); 5094 // $flow-disable-line 5095 contextVm._original = parent; 5096 } else { 5097 // the context vm passed in is a functional context as well. 5098 // in this case we want to make sure we are able to get a hold to the 5099 // real context instance. 5100 contextVm = parent; 5101 // $flow-disable-line 5102 parent = parent._original; 5103 } 5104 var isCompiled = isTrue(options._compiled); 5105 var needNormalization = !isCompiled; 5106 5107 this.data = data; 5108 this.props = props; 5109 this.children = children; 5110 this.parent = parent; 5111 this.listeners = data.on || emptyObject; 5112 this.injections = resolveInject(options.inject, parent); 5113 this.slots = function () { 5114 if (!this$1.$slots) { 5115 normalizeScopedSlots( 5116 data.scopedSlots, 5117 this$1.$slots = resolveSlots(children, parent) 5118 ); 5119 } 5120 return this$1.$slots 5121 }; 5122 5123 Object.defineProperty(this, 'scopedSlots', ({ 5124 enumerable: true, 5125 get: function get () { 5126 return normalizeScopedSlots(data.scopedSlots, this.slots()) 5127 } 5128 })); 5129 5130 // support for compiled functional template 5131 if (isCompiled) { 5132 // exposing $options for renderStatic() 5133 this.$options = options; 5134 // pre-resolve slots for renderSlot() 5135 this.$slots = this.slots(); 5136 this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots); 5137 } 5138 5139 if (options._scopeId) { 5140 this._c = function (a, b, c, d) { 5141 var vnode = createElement(contextVm, a, b, c, d, needNormalization); 5142 if (vnode && !Array.isArray(vnode)) { 5143 vnode.fnScopeId = options._scopeId; 5144 vnode.fnContext = parent; 5145 } 5146 return vnode 5147 }; 5148 } else { 5149 this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); }; 5150 } 5151} 5152 5153installRenderHelpers(FunctionalRenderContext.prototype); 5154 5155function createFunctionalComponent ( 5156 Ctor, 5157 propsData, 5158 data, 5159 contextVm, 5160 children 5161) { 5162 var options = Ctor.options; 5163 var props = {}; 5164 var propOptions = options.props; 5165 if (isDef(propOptions)) { 5166 for (var key in propOptions) { 5167 props[key] = validateProp(key, propOptions, propsData || emptyObject); 5168 } 5169 } else { 5170 if (isDef(data.attrs)) { mergeProps(props, data.attrs); } 5171 if (isDef(data.props)) { mergeProps(props, data.props); } 5172 } 5173 5174 var renderContext = new FunctionalRenderContext( 5175 data, 5176 props, 5177 children, 5178 contextVm, 5179 Ctor 5180 ); 5181 5182 var vnode = options.render.call(null, renderContext._c, renderContext); 5183 5184 if (vnode instanceof VNode) { 5185 return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext) 5186 } else if (Array.isArray(vnode)) { 5187 var vnodes = normalizeChildren(vnode) || []; 5188 var res = new Array(vnodes.length); 5189 for (var i = 0; i < vnodes.length; i++) { 5190 res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext); 5191 } 5192 return res 5193 } 5194} 5195 5196function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) { 5197 // #7817 clone node before setting fnContext, otherwise if the node is reused 5198 // (e.g. it was from a cached normal slot) the fnContext causes named slots 5199 // that should not be matched to match. 5200 var clone = cloneVNode(vnode); 5201 clone.fnContext = contextVm; 5202 clone.fnOptions = options; 5203 { 5204 (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext; 5205 } 5206 if (data.slot) { 5207 (clone.data || (clone.data = {})).slot = data.slot; 5208 } 5209 return clone 5210} 5211 5212function mergeProps (to, from) { 5213 for (var key in from) { 5214 to[camelize(key)] = from[key]; 5215 } 5216} 5217 5218/* */ 5219 5220/* */ 5221 5222/* */ 5223 5224/* */ 5225 5226// inline hooks to be invoked on component VNodes during patch 5227var componentVNodeHooks = { 5228 init: function init (vnode, hydrating) { 5229 if ( 5230 vnode.componentInstance && 5231 !vnode.componentInstance._isDestroyed && 5232 vnode.data.keepAlive 5233 ) { 5234 // kept-alive components, treat as a patch 5235 var mountedNode = vnode; // work around flow 5236 componentVNodeHooks.prepatch(mountedNode, mountedNode); 5237 } else { 5238 var child = vnode.componentInstance = createComponentInstanceForVnode( 5239 vnode, 5240 activeInstance 5241 ); 5242 child.$mount(hydrating ? vnode.elm : undefined, hydrating); 5243 } 5244 }, 5245 5246 prepatch: function prepatch (oldVnode, vnode) { 5247 var options = vnode.componentOptions; 5248 var child = vnode.componentInstance = oldVnode.componentInstance; 5249 updateChildComponent( 5250 child, 5251 options.propsData, // updated props 5252 options.listeners, // updated listeners 5253 vnode, // new parent vnode 5254 options.children // new children 5255 ); 5256 }, 5257 5258 insert: function insert (vnode) { 5259 var context = vnode.context; 5260 var componentInstance = vnode.componentInstance; 5261 if (!componentInstance._isMounted) { 5262 componentInstance._isMounted = true; 5263 callHook(componentInstance, 'mounted'); 5264 } 5265 if (vnode.data.keepAlive) { 5266 if (context._isMounted) { 5267 // vue-router#1212 5268 // During updates, a kept-alive component's child components may 5269 // change, so directly walking the tree here may call activated hooks 5270 // on incorrect children. Instead we push them into a queue which will 5271 // be processed after the whole patch process ended. 5272 queueActivatedComponent(componentInstance); 5273 } else { 5274 activateChildComponent(componentInstance, true /* direct */); 5275 } 5276 } 5277 }, 5278 5279 destroy: function destroy (vnode) { 5280 var componentInstance = vnode.componentInstance; 5281 if (!componentInstance._isDestroyed) { 5282 if (!vnode.data.keepAlive) { 5283 componentInstance.$destroy(); 5284 } else { 5285 deactivateChildComponent(componentInstance, true /* direct */); 5286 } 5287 } 5288 } 5289}; 5290 5291var hooksToMerge = Object.keys(componentVNodeHooks); 5292 5293function createComponent ( 5294 Ctor, 5295 data, 5296 context, 5297 children, 5298 tag 5299) { 5300 if (isUndef(Ctor)) { 5301 return 5302 } 5303 5304 var baseCtor = context.$options._base; 5305 5306 // plain options object: turn it into a constructor 5307 if (isObject(Ctor)) { 5308 Ctor = baseCtor.extend(Ctor); 5309 } 5310 5311 // if at this stage it's not a constructor or an async component factory, 5312 // reject. 5313 if (typeof Ctor !== 'function') { 5314 { 5315 warn(("Invalid Component definition: " + (String(Ctor))), context); 5316 } 5317 return 5318 } 5319 5320 // async component 5321 var asyncFactory; 5322 if (isUndef(Ctor.cid)) { 5323 asyncFactory = Ctor; 5324 Ctor = resolveAsyncComponent(asyncFactory, baseCtor); 5325 if (Ctor === undefined) { 5326 // return a placeholder node for async component, which is rendered 5327 // as a comment node but preserves all the raw information for the node. 5328 // the information will be used for async server-rendering and hydration. 5329 return createAsyncPlaceholder( 5330 asyncFactory, 5331 data, 5332 context, 5333 children, 5334 tag 5335 ) 5336 } 5337 } 5338 5339 data = data || {}; 5340 5341 // resolve constructor options in case global mixins are applied after 5342 // component constructor creation 5343 resolveConstructorOptions(Ctor); 5344 5345 // transform component v-model data into props & events 5346 if (isDef(data.model)) { 5347 transformModel(Ctor.options, data); 5348 } 5349 5350 // extract props 5351 var propsData = extractPropsFromVNodeData(data, Ctor, tag); 5352 5353 // functional component 5354 if (isTrue(Ctor.options.functional)) { 5355 return createFunctionalComponent(Ctor, propsData, data, context, children) 5356 } 5357 5358 // extract listeners, since these needs to be treated as 5359 // child component listeners instead of DOM listeners 5360 var listeners = data.on; 5361 // replace with listeners with .native modifier 5362 // so it gets processed during parent component patch. 5363 data.on = data.nativeOn; 5364 5365 if (isTrue(Ctor.options.abstract)) { 5366 // abstract components do not keep anything 5367 // other than props & listeners & slot 5368 5369 // work around flow 5370 var slot = data.slot; 5371 data = {}; 5372 if (slot) { 5373 data.slot = slot; 5374 } 5375 } 5376 5377 // install component management hooks onto the placeholder node 5378 installComponentHooks(data); 5379 5380 // return a placeholder vnode 5381 var name = Ctor.options.name || tag; 5382 var vnode = new VNode( 5383 ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), 5384 data, undefined, undefined, undefined, context, 5385 { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, 5386 asyncFactory 5387 ); 5388 5389 return vnode 5390} 5391 5392function createComponentInstanceForVnode ( 5393 // we know it's MountedComponentVNode but flow doesn't 5394 vnode, 5395 // activeInstance in lifecycle state 5396 parent 5397) { 5398 var options = { 5399 _isComponent: true, 5400 _parentVnode: vnode, 5401 parent: parent 5402 }; 5403 // check inline-template render functions 5404 var inlineTemplate = vnode.data.inlineTemplate; 5405 if (isDef(inlineTemplate)) { 5406 options.render = inlineTemplate.render; 5407 options.staticRenderFns = inlineTemplate.staticRenderFns; 5408 } 5409 return new vnode.componentOptions.Ctor(options) 5410} 5411 5412function installComponentHooks (data) { 5413 var hooks = data.hook || (data.hook = {}); 5414 for (var i = 0; i < hooksToMerge.length; i++) { 5415 var key = hooksToMerge[i]; 5416 var existing = hooks[key]; 5417 var toMerge = componentVNodeHooks[key]; 5418 if (existing !== toMerge && !(existing && existing._merged)) { 5419 hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge; 5420 } 5421 } 5422} 5423 5424function mergeHook$1 (f1, f2) { 5425 var merged = function (a, b) { 5426 // flow complains about extra args which is why we use any 5427 f1(a, b); 5428 f2(a, b); 5429 }; 5430 merged._merged = true; 5431 return merged 5432} 5433 5434// transform component v-model info (value and callback) into 5435// prop and event handler respectively. 5436function transformModel (options, data) { 5437 var prop = (options.model && options.model.prop) || 'value'; 5438 var event = (options.model && options.model.event) || 'input' 5439 ;(data.attrs || (data.attrs = {}))[prop] = data.model.value; 5440 var on = data.on || (data.on = {}); 5441 var existing = on[event]; 5442 var callback = data.model.callback; 5443 if (isDef(existing)) { 5444 if ( 5445 Array.isArray(existing) 5446 ? existing.indexOf(callback) === -1 5447 : existing !== callback 5448 ) { 5449 on[event] = [callback].concat(existing); 5450 } 5451 } else { 5452 on[event] = callback; 5453 } 5454} 5455 5456/* */ 5457 5458var SIMPLE_NORMALIZE = 1; 5459var ALWAYS_NORMALIZE = 2; 5460 5461// wrapper function for providing a more flexible interface 5462// without getting yelled at by flow 5463function createElement ( 5464 context, 5465 tag, 5466 data, 5467 children, 5468 normalizationType, 5469 alwaysNormalize 5470) { 5471 if (Array.isArray(data) || isPrimitive(data)) { 5472 normalizationType = children; 5473 children = data; 5474 data = undefined; 5475 } 5476 if (isTrue(alwaysNormalize)) { 5477 normalizationType = ALWAYS_NORMALIZE; 5478 } 5479 return _createElement(context, tag, data, children, normalizationType) 5480} 5481 5482function _createElement ( 5483 context, 5484 tag, 5485 data, 5486 children, 5487 normalizationType 5488) { 5489 if (isDef(data) && isDef((data).__ob__)) { 5490 warn( 5491 "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 5492 'Always create fresh vnode data objects in each render!', 5493 context 5494 ); 5495 return createEmptyVNode() 5496 } 5497 // object syntax in v-bind 5498 if (isDef(data) && isDef(data.is)) { 5499 tag = data.is; 5500 } 5501 if (!tag) { 5502 // in case of component :is set to falsy value 5503 return createEmptyVNode() 5504 } 5505 // warn against non-primitive key 5506 if (isDef(data) && isDef(data.key) && !isPrimitive(data.key) 5507 ) { 5508 { 5509 warn( 5510 'Avoid using non-primitive value as key, ' + 5511 'use string/number value instead.', 5512 context 5513 ); 5514 } 5515 } 5516 // support single function children as default scoped slot 5517 if (Array.isArray(children) && 5518 typeof children[0] === 'function' 5519 ) { 5520 data = data || {}; 5521 data.scopedSlots = { default: children[0] }; 5522 children.length = 0; 5523 } 5524 if (normalizationType === ALWAYS_NORMALIZE) { 5525 children = normalizeChildren(children); 5526 } else if (normalizationType === SIMPLE_NORMALIZE) { 5527 children = simpleNormalizeChildren(children); 5528 } 5529 var vnode, ns; 5530 if (typeof tag === 'string') { 5531 var Ctor; 5532 ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag); 5533 if (config.isReservedTag(tag)) { 5534 // platform built-in elements 5535 if (isDef(data) && isDef(data.nativeOn) && data.tag !== 'component') { 5536 warn( 5537 ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), 5538 context 5539 ); 5540 } 5541 vnode = new VNode( 5542 config.parsePlatformTagName(tag), data, children, 5543 undefined, undefined, context 5544 ); 5545 } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) { 5546 // component 5547 vnode = createComponent(Ctor, data, context, children, tag); 5548 } else { 5549 // unknown or unlisted namespaced elements 5550 // check at runtime because it may get assigned a namespace when its 5551 // parent normalizes children 5552 vnode = new VNode( 5553 tag, data, children, 5554 undefined, undefined, context 5555 ); 5556 } 5557 } else { 5558 // direct component options / constructor 5559 vnode = createComponent(tag, data, context, children); 5560 } 5561 if (Array.isArray(vnode)) { 5562 return vnode 5563 } else if (isDef(vnode)) { 5564 if (isDef(ns)) { applyNS(vnode, ns); } 5565 if (isDef(data)) { registerDeepBindings(data); } 5566 return vnode 5567 } else { 5568 return createEmptyVNode() 5569 } 5570} 5571 5572function applyNS (vnode, ns, force) { 5573 vnode.ns = ns; 5574 if (vnode.tag === 'foreignObject') { 5575 // use default namespace inside foreignObject 5576 ns = undefined; 5577 force = true; 5578 } 5579 if (isDef(vnode.children)) { 5580 for (var i = 0, l = vnode.children.length; i < l; i++) { 5581 var child = vnode.children[i]; 5582 if (isDef(child.tag) && ( 5583 isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) { 5584 applyNS(child, ns, force); 5585 } 5586 } 5587 } 5588} 5589 5590// ref #5318 5591// necessary to ensure parent re-render when deep bindings like :style and 5592// :class are used on slot nodes 5593function registerDeepBindings (data) { 5594 if (isObject(data.style)) { 5595 traverse(data.style); 5596 } 5597 if (isObject(data.class)) { 5598 traverse(data.class); 5599 } 5600} 5601 5602/* */ 5603 5604function initRender (vm) { 5605 vm._vnode = null; // the root of the child tree 5606 vm._staticTrees = null; // v-once cached trees 5607 var options = vm.$options; 5608 var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree 5609 var renderContext = parentVnode && parentVnode.context; 5610 vm.$slots = resolveSlots(options._renderChildren, renderContext); 5611 vm.$scopedSlots = emptyObject; 5612 // bind the createElement fn to this instance 5613 // so that we get proper render context inside it. 5614 // args order: tag, data, children, normalizationType, alwaysNormalize 5615 // internal version is used by render functions compiled from templates 5616 vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); }; 5617 // normalization is always applied for the public version, used in 5618 // user-written render functions. 5619 vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); }; 5620 5621 // $attrs & $listeners are exposed for easier HOC creation. 5622 // they need to be reactive so that HOCs using them are always updated 5623 var parentData = parentVnode && parentVnode.data; 5624 5625 /* istanbul ignore else */ 5626 { 5627 defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () { 5628 !isUpdatingChildComponent && warn("$attrs is readonly.", vm); 5629 }, true); 5630 defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () { 5631 !isUpdatingChildComponent && warn("$listeners is readonly.", vm); 5632 }, true); 5633 } 5634} 5635 5636var currentRenderingInstance = null; 5637 5638function renderMixin (Vue) { 5639 // install runtime convenience helpers 5640 installRenderHelpers(Vue.prototype); 5641 5642 Vue.prototype.$nextTick = function (fn) { 5643 return nextTick(fn, this) 5644 }; 5645 5646 Vue.prototype._render = function () { 5647 var vm = this; 5648 var ref = vm.$options; 5649 var render = ref.render; 5650 var _parentVnode = ref._parentVnode; 5651 5652 if (_parentVnode) { 5653 vm.$scopedSlots = normalizeScopedSlots( 5654 _parentVnode.data.scopedSlots, 5655 vm.$slots, 5656 vm.$scopedSlots 5657 ); 5658 } 5659 5660 // set parent vnode. this allows render functions to have access 5661 // to the data on the placeholder node. 5662 vm.$vnode = _parentVnode; 5663 // render self 5664 var vnode; 5665 try { 5666 // There's no need to maintain a stack because all render fns are called 5667 // separately from one another. Nested component's render fns are called 5668 // when parent component is patched. 5669 currentRenderingInstance = vm; 5670 vnode = render.call(vm._renderProxy, vm.$createElement); 5671 } catch (e) { 5672 handleError(e, vm, "render"); 5673 // return error render result, 5674 // or previous vnode to prevent render error causing blank component 5675 /* istanbul ignore else */ 5676 if (vm.$options.renderError) { 5677 try { 5678 vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e); 5679 } catch (e) { 5680 handleError(e, vm, "renderError"); 5681 vnode = vm._vnode; 5682 } 5683 } else { 5684 vnode = vm._vnode; 5685 } 5686 } finally { 5687 currentRenderingInstance = null; 5688 } 5689 // if the returned array contains only a single node, allow it 5690 if (Array.isArray(vnode) && vnode.length === 1) { 5691 vnode = vnode[0]; 5692 } 5693 // return empty vnode in case the render function errored out 5694 if (!(vnode instanceof VNode)) { 5695 if (Array.isArray(vnode)) { 5696 warn( 5697 'Multiple root nodes returned from render function. Render function ' + 5698 'should return a single root node.', 5699 vm 5700 ); 5701 } 5702 vnode = createEmptyVNode(); 5703 } 5704 // set parent 5705 vnode.parent = _parentVnode; 5706 return vnode 5707 }; 5708} 5709 5710/* */ 5711 5712function ensureCtor (comp, base) { 5713 if ( 5714 comp.__esModule || 5715 (hasSymbol && comp[Symbol.toStringTag] === 'Module') 5716 ) { 5717 comp = comp.default; 5718 } 5719 return isObject(comp) 5720 ? base.extend(comp) 5721 : comp 5722} 5723 5724function createAsyncPlaceholder ( 5725 factory, 5726 data, 5727 context, 5728 children, 5729 tag 5730) { 5731 var node = createEmptyVNode(); 5732 node.asyncFactory = factory; 5733 node.asyncMeta = { data: data, context: context, children: children, tag: tag }; 5734 return node 5735} 5736 5737function resolveAsyncComponent ( 5738 factory, 5739 baseCtor 5740) { 5741 if (isTrue(factory.error) && isDef(factory.errorComp)) { 5742 return factory.errorComp 5743 } 5744 5745 if (isDef(factory.resolved)) { 5746 return factory.resolved 5747 } 5748 5749 var owner = currentRenderingInstance; 5750 if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) { 5751 // already pending 5752 factory.owners.push(owner); 5753 } 5754 5755 if (isTrue(factory.loading) && isDef(factory.loadingComp)) { 5756 return factory.loadingComp 5757 } 5758 5759 if (owner && !isDef(factory.owners)) { 5760 var owners = factory.owners = [owner]; 5761 var sync = true; 5762 var timerLoading = null; 5763 var timerTimeout = null 5764 5765 ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); }); 5766 5767 var forceRender = function (renderCompleted) { 5768 for (var i = 0, l = owners.length; i < l; i++) { 5769 (owners[i]).$forceUpdate(); 5770 } 5771 5772 if (renderCompleted) { 5773 owners.length = 0; 5774 if (timerLoading !== null) { 5775 clearTimeout(timerLoading); 5776 timerLoading = null; 5777 } 5778 if (timerTimeout !== null) { 5779 clearTimeout(timerTimeout); 5780 timerTimeout = null; 5781 } 5782 } 5783 }; 5784 5785 var resolve = once(function (res) { 5786 // cache resolved 5787 factory.resolved = ensureCtor(res, baseCtor); 5788 // invoke callbacks only if this is not a synchronous resolve 5789 // (async resolves are shimmed as synchronous during SSR) 5790 if (!sync) { 5791 forceRender(true); 5792 } else { 5793 owners.length = 0; 5794 } 5795 }); 5796 5797 var reject = once(function (reason) { 5798 warn( 5799 "Failed to resolve async component: " + (String(factory)) + 5800 (reason ? ("\nReason: " + reason) : '') 5801 ); 5802 if (isDef(factory.errorComp)) { 5803 factory.error = true; 5804 forceRender(true); 5805 } 5806 }); 5807 5808 var res = factory(resolve, reject); 5809 5810 if (isObject(res)) { 5811 if (isPromise(res)) { 5812 // () => Promise 5813 if (isUndef(factory.resolved)) { 5814 res.then(resolve, reject); 5815 } 5816 } else if (isPromise(res.component)) { 5817 res.component.then(resolve, reject); 5818 5819 if (isDef(res.error)) { 5820 factory.errorComp = ensureCtor(res.error, baseCtor); 5821 } 5822 5823 if (isDef(res.loading)) { 5824 factory.loadingComp = ensureCtor(res.loading, baseCtor); 5825 if (res.delay === 0) { 5826 factory.loading = true; 5827 } else { 5828 timerLoading = setTimeout(function () { 5829 timerLoading = null; 5830 if (isUndef(factory.resolved) && isUndef(factory.error)) { 5831 factory.loading = true; 5832 forceRender(false); 5833 } 5834 }, res.delay || 200); 5835 } 5836 } 5837 5838 if (isDef(res.timeout)) { 5839 timerTimeout = setTimeout(function () { 5840 timerTimeout = null; 5841 if (isUndef(factory.resolved)) { 5842 reject( 5843 "timeout (" + (res.timeout) + "ms)" 5844 ); 5845 } 5846 }, res.timeout); 5847 } 5848 } 5849 } 5850 5851 sync = false; 5852 // return in case resolved synchronously 5853 return factory.loading 5854 ? factory.loadingComp 5855 : factory.resolved 5856 } 5857} 5858 5859/* */ 5860 5861function getFirstComponentChild (children) { 5862 if (Array.isArray(children)) { 5863 for (var i = 0; i < children.length; i++) { 5864 var c = children[i]; 5865 if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { 5866 return c 5867 } 5868 } 5869 } 5870} 5871 5872/* */ 5873 5874/* */ 5875 5876function initEvents (vm) { 5877 vm._events = Object.create(null); 5878 vm._hasHookEvent = false; 5879 // init parent attached events 5880 var listeners = vm.$options._parentListeners; 5881 if (listeners) { 5882 updateComponentListeners(vm, listeners); 5883 } 5884} 5885 5886var target; 5887 5888function add (event, fn) { 5889 target.$on(event, fn); 5890} 5891 5892function remove$1 (event, fn) { 5893 target.$off(event, fn); 5894} 5895 5896function createOnceHandler (event, fn) { 5897 var _target = target; 5898 return function onceHandler () { 5899 var res = fn.apply(null, arguments); 5900 if (res !== null) { 5901 _target.$off(event, onceHandler); 5902 } 5903 } 5904} 5905 5906function updateComponentListeners ( 5907 vm, 5908 listeners, 5909 oldListeners 5910) { 5911 target = vm; 5912 updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm); 5913 target = undefined; 5914} 5915 5916function eventsMixin (Vue) { 5917 var hookRE = /^hook:/; 5918 Vue.prototype.$on = function (event, fn) { 5919 var vm = this; 5920 if (Array.isArray(event)) { 5921 for (var i = 0, l = event.length; i < l; i++) { 5922 vm.$on(event[i], fn); 5923 } 5924 } else { 5925 (vm._events[event] || (vm._events[event] = [])).push(fn); 5926 // optimize hook:event cost by using a boolean flag marked at registration 5927 // instead of a hash lookup 5928 if (hookRE.test(event)) { 5929 vm._hasHookEvent = true; 5930 } 5931 } 5932 return vm 5933 }; 5934 5935 Vue.prototype.$once = function (event, fn) { 5936 var vm = this; 5937 function on () { 5938 vm.$off(event, on); 5939 fn.apply(vm, arguments); 5940 } 5941 on.fn = fn; 5942 vm.$on(event, on); 5943 return vm 5944 }; 5945 5946 Vue.prototype.$off = function (event, fn) { 5947 var vm = this; 5948 // all 5949 if (!arguments.length) { 5950 vm._events = Object.create(null); 5951 return vm 5952 } 5953 // array of events 5954 if (Array.isArray(event)) { 5955 for (var i$1 = 0, l = event.length; i$1 < l; i$1++) { 5956 vm.$off(event[i$1], fn); 5957 } 5958 return vm 5959 } 5960 // specific event 5961 var cbs = vm._events[event]; 5962 if (!cbs) { 5963 return vm 5964 } 5965 if (!fn) { 5966 vm._events[event] = null; 5967 return vm 5968 } 5969 // specific handler 5970 var cb; 5971 var i = cbs.length; 5972 while (i--) { 5973 cb = cbs[i]; 5974 if (cb === fn || cb.fn === fn) { 5975 cbs.splice(i, 1); 5976 break 5977 } 5978 } 5979 return vm 5980 }; 5981 5982 Vue.prototype.$emit = function (event) { 5983 var vm = this; 5984 { 5985 var lowerCaseEvent = event.toLowerCase(); 5986 if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) { 5987 tip( 5988 "Event \"" + lowerCaseEvent + "\" is emitted in component " + 5989 (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " + 5990 "Note that HTML attributes are case-insensitive and you cannot use " + 5991 "v-on to listen to camelCase events when using in-DOM templates. " + 5992 "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"." 5993 ); 5994 } 5995 } 5996 var cbs = vm._events[event]; 5997 if (cbs) { 5998 cbs = cbs.length > 1 ? toArray(cbs) : cbs; 5999 var args = toArray(arguments, 1); 6000 var info = "event handler for \"" + event + "\""; 6001 for (var i = 0, l = cbs.length; i < l; i++) { 6002 invokeWithErrorHandling(cbs[i], vm, args, vm, info); 6003 } 6004 } 6005 return vm 6006 }; 6007} 6008 6009/* */ 6010 6011var activeInstance = null; 6012var isUpdatingChildComponent = false; 6013 6014function setActiveInstance(vm) { 6015 var prevActiveInstance = activeInstance; 6016 activeInstance = vm; 6017 return function () { 6018 activeInstance = prevActiveInstance; 6019 } 6020} 6021 6022function initLifecycle (vm) { 6023 var options = vm.$options; 6024 6025 // locate first non-abstract parent 6026 var parent = options.parent; 6027 if (parent && !options.abstract) { 6028 while (parent.$options.abstract && parent.$parent) { 6029 parent = parent.$parent; 6030 } 6031 parent.$children.push(vm); 6032 } 6033 6034 vm.$parent = parent; 6035 vm.$root = parent ? parent.$root : vm; 6036 6037 vm.$children = []; 6038 vm.$refs = {}; 6039 6040 vm._watcher = null; 6041 vm._inactive = null; 6042 vm._directInactive = false; 6043 vm._isMounted = false; 6044 vm._isDestroyed = false; 6045 vm._isBeingDestroyed = false; 6046} 6047 6048function lifecycleMixin (Vue) { 6049 Vue.prototype._update = function (vnode, hydrating) { 6050 var vm = this; 6051 var prevEl = vm.$el; 6052 var prevVnode = vm._vnode; 6053 var restoreActiveInstance = setActiveInstance(vm); 6054 vm._vnode = vnode; 6055 // Vue.prototype.__patch__ is injected in entry points 6056 // based on the rendering backend used. 6057 if (!prevVnode) { 6058 // initial render 6059 vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */); 6060 } else { 6061 // updates 6062 vm.$el = vm.__patch__(prevVnode, vnode); 6063 } 6064 restoreActiveInstance(); 6065 // update __vue__ reference 6066 if (prevEl) { 6067 prevEl.__vue__ = null; 6068 } 6069 if (vm.$el) { 6070 vm.$el.__vue__ = vm; 6071 } 6072 // if parent is an HOC, update its $el as well 6073 if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { 6074 vm.$parent.$el = vm.$el; 6075 } 6076 // updated hook is called by the scheduler to ensure that children are 6077 // updated in a parent's updated hook. 6078 }; 6079 6080 Vue.prototype.$forceUpdate = function () { 6081 var vm = this; 6082 if (vm._watcher) { 6083 vm._watcher.update(); 6084 } 6085 }; 6086 6087 Vue.prototype.$destroy = function () { 6088 var vm = this; 6089 if (vm._isBeingDestroyed) { 6090 return 6091 } 6092 callHook(vm, 'beforeDestroy'); 6093 vm._isBeingDestroyed = true; 6094 // remove self from parent 6095 var parent = vm.$parent; 6096 if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { 6097 remove(parent.$children, vm); 6098 } 6099 // teardown watchers 6100 if (vm._watcher) { 6101 vm._watcher.teardown(); 6102 } 6103 var i = vm._watchers.length; 6104 while (i--) { 6105 vm._watchers[i].teardown(); 6106 } 6107 // remove reference from data ob 6108 // frozen object may not have observer. 6109 if (vm._data.__ob__) { 6110 vm._data.__ob__.vmCount--; 6111 } 6112 // call the last hook... 6113 vm._isDestroyed = true; 6114 // invoke destroy hooks on current rendered tree 6115 vm.__patch__(vm._vnode, null); 6116 // fire destroyed hook 6117 callHook(vm, 'destroyed'); 6118 // turn off all instance listeners. 6119 vm.$off(); 6120 // remove __vue__ reference 6121 if (vm.$el) { 6122 vm.$el.__vue__ = null; 6123 } 6124 // release circular reference (#6759) 6125 if (vm.$vnode) { 6126 vm.$vnode.parent = null; 6127 } 6128 }; 6129} 6130 6131function mountComponent ( 6132 vm, 6133 el, 6134 hydrating 6135) { 6136 vm.$el = el; 6137 if (!vm.$options.render) { 6138 vm.$options.render = createEmptyVNode; 6139 { 6140 /* istanbul ignore if */ 6141 if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') || 6142 vm.$options.el || el) { 6143 warn( 6144 'You are using the runtime-only build of Vue where the template ' + 6145 'compiler is not available. Either pre-compile the templates into ' + 6146 'render functions, or use the compiler-included build.', 6147 vm 6148 ); 6149 } else { 6150 warn( 6151 'Failed to mount component: template or render function not defined.', 6152 vm 6153 ); 6154 } 6155 } 6156 } 6157 callHook(vm, 'beforeMount'); 6158 6159 var updateComponent; 6160 /* istanbul ignore if */ 6161 if (config.performance && mark) { 6162 updateComponent = function () { 6163 var name = vm._name; 6164 var id = vm._uid; 6165 var startTag = "vue-perf-start:" + id; 6166 var endTag = "vue-perf-end:" + id; 6167 6168 mark(startTag); 6169 var vnode = vm._render(); 6170 mark(endTag); 6171 measure(("vue " + name + " render"), startTag, endTag); 6172 6173 mark(startTag); 6174 vm._update(vnode, hydrating); 6175 mark(endTag); 6176 measure(("vue " + name + " patch"), startTag, endTag); 6177 }; 6178 } else { 6179 updateComponent = function () { 6180 vm._update(vm._render(), hydrating); 6181 }; 6182 } 6183 6184 // we set this to vm._watcher inside the watcher's constructor 6185 // since the watcher's initial patch may call $forceUpdate (e.g. inside child 6186 // component's mounted hook), which relies on vm._watcher being already defined 6187 new Watcher(vm, updateComponent, noop, { 6188 before: function before () { 6189 if (vm._isMounted && !vm._isDestroyed) { 6190 callHook(vm, 'beforeUpdate'); 6191 } 6192 } 6193 }, true /* isRenderWatcher */); 6194 hydrating = false; 6195 6196 // manually mounted instance, call mounted on self 6197 // mounted is called for render-created child components in its inserted hook 6198 if (vm.$vnode == null) { 6199 vm._isMounted = true; 6200 callHook(vm, 'mounted'); 6201 } 6202 return vm 6203} 6204 6205function updateChildComponent ( 6206 vm, 6207 propsData, 6208 listeners, 6209 parentVnode, 6210 renderChildren 6211) { 6212 { 6213 isUpdatingChildComponent = true; 6214 } 6215 6216 // determine whether component has slot children 6217 // we need to do this before overwriting $options._renderChildren. 6218 6219 // check if there are dynamic scopedSlots (hand-written or compiled but with 6220 // dynamic slot names). Static scoped slots compiled from template has the 6221 // "$stable" marker. 6222 var newScopedSlots = parentVnode.data.scopedSlots; 6223 var oldScopedSlots = vm.$scopedSlots; 6224 var hasDynamicScopedSlot = !!( 6225 (newScopedSlots && !newScopedSlots.$stable) || 6226 (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) || 6227 (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) || 6228 (!newScopedSlots && vm.$scopedSlots.$key) 6229 ); 6230 6231 // Any static slot children from the parent may have changed during parent's 6232 // update. Dynamic scoped slots may also have changed. In such cases, a forced 6233 // update is necessary to ensure correctness. 6234 var needsForceUpdate = !!( 6235 renderChildren || // has new static slots 6236 vm.$options._renderChildren || // has old static slots 6237 hasDynamicScopedSlot 6238 ); 6239 6240 vm.$options._parentVnode = parentVnode; 6241 vm.$vnode = parentVnode; // update vm's placeholder node without re-render 6242 6243 if (vm._vnode) { // update child tree's parent 6244 vm._vnode.parent = parentVnode; 6245 } 6246 vm.$options._renderChildren = renderChildren; 6247 6248 // update $attrs and $listeners hash 6249 // these are also reactive so they may trigger child update if the child 6250 // used them during render 6251 vm.$attrs = parentVnode.data.attrs || emptyObject; 6252 vm.$listeners = listeners || emptyObject; 6253 6254 // update props 6255 if (propsData && vm.$options.props) { 6256 toggleObserving(false); 6257 var props = vm._props; 6258 var propKeys = vm.$options._propKeys || []; 6259 for (var i = 0; i < propKeys.length; i++) { 6260 var key = propKeys[i]; 6261 var propOptions = vm.$options.props; // wtf flow? 6262 props[key] = validateProp(key, propOptions, propsData, vm); 6263 } 6264 toggleObserving(true); 6265 // keep a copy of raw propsData 6266 vm.$options.propsData = propsData; 6267 } 6268 6269 // update listeners 6270 listeners = listeners || emptyObject; 6271 var oldListeners = vm.$options._parentListeners; 6272 vm.$options._parentListeners = listeners; 6273 updateComponentListeners(vm, listeners, oldListeners); 6274 6275 // resolve slots + force update if has children 6276 if (needsForceUpdate) { 6277 vm.$slots = resolveSlots(renderChildren, parentVnode.context); 6278 vm.$forceUpdate(); 6279 } 6280 6281 { 6282 isUpdatingChildComponent = false; 6283 } 6284} 6285 6286function isInInactiveTree (vm) { 6287 while (vm && (vm = vm.$parent)) { 6288 if (vm._inactive) { return true } 6289 } 6290 return false 6291} 6292 6293function activateChildComponent (vm, direct) { 6294 if (direct) { 6295 vm._directInactive = false; 6296 if (isInInactiveTree(vm)) { 6297 return 6298 } 6299 } else if (vm._directInactive) { 6300 return 6301 } 6302 if (vm._inactive || vm._inactive === null) { 6303 vm._inactive = false; 6304 for (var i = 0; i < vm.$children.length; i++) { 6305 activateChildComponent(vm.$children[i]); 6306 } 6307 callHook(vm, 'activated'); 6308 } 6309} 6310 6311function deactivateChildComponent (vm, direct) { 6312 if (direct) { 6313 vm._directInactive = true; 6314 if (isInInactiveTree(vm)) { 6315 return 6316 } 6317 } 6318 if (!vm._inactive) { 6319 vm._inactive = true; 6320 for (var i = 0; i < vm.$children.length; i++) { 6321 deactivateChildComponent(vm.$children[i]); 6322 } 6323 callHook(vm, 'deactivated'); 6324 } 6325} 6326 6327function callHook (vm, hook) { 6328 // #7573 disable dep collection when invoking lifecycle hooks 6329 pushTarget(); 6330 var handlers = vm.$options[hook]; 6331 var info = hook + " hook"; 6332 if (handlers) { 6333 for (var i = 0, j = handlers.length; i < j; i++) { 6334 invokeWithErrorHandling(handlers[i], vm, null, vm, info); 6335 } 6336 } 6337 if (vm._hasHookEvent) { 6338 vm.$emit('hook:' + hook); 6339 } 6340 popTarget(); 6341} 6342 6343/* */ 6344 6345var MAX_UPDATE_COUNT = 100; 6346 6347var queue = []; 6348var activatedChildren = []; 6349var has = {}; 6350var circular = {}; 6351var waiting = false; 6352var flushing = false; 6353var index = 0; 6354 6355/** 6356 * Reset the scheduler's state. 6357 */ 6358function resetSchedulerState () { 6359 index = queue.length = activatedChildren.length = 0; 6360 has = {}; 6361 { 6362 circular = {}; 6363 } 6364 waiting = flushing = false; 6365} 6366 6367// Async edge case #6566 requires saving the timestamp when event listeners are 6368// attached. However, calling performance.now() has a perf overhead especially 6369// if the page has thousands of event listeners. Instead, we take a timestamp 6370// every time the scheduler flushes and use that for all event listeners 6371// attached during that flush. 6372var currentFlushTimestamp = 0; 6373 6374// Async edge case fix requires storing an event listener's attach timestamp. 6375var getNow = Date.now; 6376 6377// Determine what event timestamp the browser is using. Annoyingly, the 6378// timestamp can either be hi-res (relative to page load) or low-res 6379// (relative to UNIX epoch), so in order to compare time we have to use the 6380// same timestamp type when saving the flush timestamp. 6381// All IE versions use low-res event timestamps, and have problematic clock 6382// implementations (#9632) 6383if (inBrowser && !isIE) { 6384 var performance = window.performance; 6385 if ( 6386 performance && 6387 typeof performance.now === 'function' && 6388 getNow() > document.createEvent('Event').timeStamp 6389 ) { 6390 // if the event timestamp, although evaluated AFTER the Date.now(), is 6391 // smaller than it, it means the event is using a hi-res timestamp, 6392 // and we need to use the hi-res version for event listener timestamps as 6393 // well. 6394 getNow = function () { return performance.now(); }; 6395 } 6396} 6397 6398/** 6399 * Flush both queues and run the watchers. 6400 */ 6401function flushSchedulerQueue () { 6402 currentFlushTimestamp = getNow(); 6403 flushing = true; 6404 var watcher, id; 6405 6406 // Sort queue before flush. 6407 // This ensures that: 6408 // 1. Components are updated from parent to child. (because parent is always 6409 // created before the child) 6410 // 2. A component's user watchers are run before its render watcher (because 6411 // user watchers are created before the render watcher) 6412 // 3. If a component is destroyed during a parent component's watcher run, 6413 // its watchers can be skipped. 6414 queue.sort(function (a, b) { return a.id - b.id; }); 6415 6416 // do not cache length because more watchers might be pushed 6417 // as we run existing watchers 6418 for (index = 0; index < queue.length; index++) { 6419 watcher = queue[index]; 6420 if (watcher.before) { 6421 watcher.before(); 6422 } 6423 id = watcher.id; 6424 has[id] = null; 6425 watcher.run(); 6426 // in dev build, check and stop circular updates. 6427 if (has[id] != null) { 6428 circular[id] = (circular[id] || 0) + 1; 6429 if (circular[id] > MAX_UPDATE_COUNT) { 6430 warn( 6431 'You may have an infinite update loop ' + ( 6432 watcher.user 6433 ? ("in watcher with expression \"" + (watcher.expression) + "\"") 6434 : "in a component render function." 6435 ), 6436 watcher.vm 6437 ); 6438 break 6439 } 6440 } 6441 } 6442 6443 // keep copies of post queues before resetting state 6444 var activatedQueue = activatedChildren.slice(); 6445 var updatedQueue = queue.slice(); 6446 6447 resetSchedulerState(); 6448 6449 // call component updated and activated hooks 6450 callActivatedHooks(activatedQueue); 6451 callUpdatedHooks(updatedQueue); 6452 6453 // devtool hook 6454 /* istanbul ignore if */ 6455 if (devtools && config.devtools) { 6456 devtools.emit('flush'); 6457 } 6458} 6459 6460function callUpdatedHooks (queue) { 6461 var i = queue.length; 6462 while (i--) { 6463 var watcher = queue[i]; 6464 var vm = watcher.vm; 6465 if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) { 6466 callHook(vm, 'updated'); 6467 } 6468 } 6469} 6470 6471/** 6472 * Queue a kept-alive component that was activated during patch. 6473 * The queue will be processed after the entire tree has been patched. 6474 */ 6475function queueActivatedComponent (vm) { 6476 // setting _inactive to false here so that a render function can 6477 // rely on checking whether it's in an inactive tree (e.g. router-view) 6478 vm._inactive = false; 6479 activatedChildren.push(vm); 6480} 6481 6482function callActivatedHooks (queue) { 6483 for (var i = 0; i < queue.length; i++) { 6484 queue[i]._inactive = true; 6485 activateChildComponent(queue[i], true /* true */); 6486 } 6487} 6488 6489/** 6490 * Push a watcher into the watcher queue. 6491 * Jobs with duplicate IDs will be skipped unless it's 6492 * pushed when the queue is being flushed. 6493 */ 6494function queueWatcher (watcher) { 6495 var id = watcher.id; 6496 if (has[id] == null) { 6497 has[id] = true; 6498 if (!flushing) { 6499 queue.push(watcher); 6500 } else { 6501 // if already flushing, splice the watcher based on its id 6502 // if already past its id, it will be run next immediately. 6503 var i = queue.length - 1; 6504 while (i > index && queue[i].id > watcher.id) { 6505 i--; 6506 } 6507 queue.splice(i + 1, 0, watcher); 6508 } 6509 // queue the flush 6510 if (!waiting) { 6511 waiting = true; 6512 6513 if (!config.async) { 6514 flushSchedulerQueue(); 6515 return 6516 } 6517 nextTick(flushSchedulerQueue); 6518 } 6519 } 6520} 6521 6522/* */ 6523 6524 6525 6526var uid$2 = 0; 6527 6528/** 6529 * A watcher parses an expression, collects dependencies, 6530 * and fires callback when the expression value changes. 6531 * This is used for both the $watch() api and directives. 6532 */ 6533var Watcher = function Watcher ( 6534 vm, 6535 expOrFn, 6536 cb, 6537 options, 6538 isRenderWatcher 6539) { 6540 this.vm = vm; 6541 if (isRenderWatcher) { 6542 vm._watcher = this; 6543 } 6544 vm._watchers.push(this); 6545 // options 6546 if (options) { 6547 this.deep = !!options.deep; 6548 this.user = !!options.user; 6549 this.lazy = !!options.lazy; 6550 this.sync = !!options.sync; 6551 this.before = options.before; 6552 } else { 6553 this.deep = this.user = this.lazy = this.sync = false; 6554 } 6555 this.cb = cb; 6556 this.id = ++uid$2; // uid for batching 6557 this.active = true; 6558 this.dirty = this.lazy; // for lazy watchers 6559 this.deps = []; 6560 this.newDeps = []; 6561 this.depIds = new _Set(); 6562 this.newDepIds = new _Set(); 6563 this.expression = expOrFn.toString(); 6564 // parse expression for getter 6565 if (typeof expOrFn === 'function') { 6566 this.getter = expOrFn; 6567 } else { 6568 this.getter = parsePath(expOrFn); 6569 if (!this.getter) { 6570 this.getter = noop; 6571 warn( 6572 "Failed watching path: \"" + expOrFn + "\" " + 6573 'Watcher only accepts simple dot-delimited paths. ' + 6574 'For full control, use a function instead.', 6575 vm 6576 ); 6577 } 6578 } 6579 this.value = this.lazy 6580 ? undefined 6581 : this.get(); 6582}; 6583 6584/** 6585 * Evaluate the getter, and re-collect dependencies. 6586 */ 6587Watcher.prototype.get = function get () { 6588 pushTarget(this); 6589 var value; 6590 var vm = this.vm; 6591 try { 6592 value = this.getter.call(vm, vm); 6593 } catch (e) { 6594 if (this.user) { 6595 handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\"")); 6596 } else { 6597 throw e 6598 } 6599 } finally { 6600 // "touch" every property so they are all tracked as 6601 // dependencies for deep watching 6602 if (this.deep) { 6603 traverse(value); 6604 } 6605 popTarget(); 6606 this.cleanupDeps(); 6607 } 6608 return value 6609}; 6610 6611/** 6612 * Add a dependency to this directive. 6613 */ 6614Watcher.prototype.addDep = function addDep (dep) { 6615 var id = dep.id; 6616 if (!this.newDepIds.has(id)) { 6617 this.newDepIds.add(id); 6618 this.newDeps.push(dep); 6619 if (!this.depIds.has(id)) { 6620 dep.addSub(this); 6621 } 6622 } 6623}; 6624 6625/** 6626 * Clean up for dependency collection. 6627 */ 6628Watcher.prototype.cleanupDeps = function cleanupDeps () { 6629 var i = this.deps.length; 6630 while (i--) { 6631 var dep = this.deps[i]; 6632 if (!this.newDepIds.has(dep.id)) { 6633 dep.removeSub(this); 6634 } 6635 } 6636 var tmp = this.depIds; 6637 this.depIds = this.newDepIds; 6638 this.newDepIds = tmp; 6639 this.newDepIds.clear(); 6640 tmp = this.deps; 6641 this.deps = this.newDeps; 6642 this.newDeps = tmp; 6643 this.newDeps.length = 0; 6644}; 6645 6646/** 6647 * Subscriber interface. 6648 * Will be called when a dependency changes. 6649 */ 6650Watcher.prototype.update = function update () { 6651 /* istanbul ignore else */ 6652 if (this.lazy) { 6653 this.dirty = true; 6654 } else if (this.sync) { 6655 this.run(); 6656 } else { 6657 queueWatcher(this); 6658 } 6659}; 6660 6661/** 6662 * Scheduler job interface. 6663 * Will be called by the scheduler. 6664 */ 6665Watcher.prototype.run = function run () { 6666 if (this.active) { 6667 var value = this.get(); 6668 if ( 6669 value !== this.value || 6670 // Deep watchers and watchers on Object/Arrays should fire even 6671 // when the value is the same, because the value may 6672 // have mutated. 6673 isObject(value) || 6674 this.deep 6675 ) { 6676 // set new value 6677 var oldValue = this.value; 6678 this.value = value; 6679 if (this.user) { 6680 var info = "callback for watcher \"" + (this.expression) + "\""; 6681 invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info); 6682 } else { 6683 this.cb.call(this.vm, value, oldValue); 6684 } 6685 } 6686 } 6687}; 6688 6689/** 6690 * Evaluate the value of the watcher. 6691 * This only gets called for lazy watchers. 6692 */ 6693Watcher.prototype.evaluate = function evaluate () { 6694 this.value = this.get(); 6695 this.dirty = false; 6696}; 6697 6698/** 6699 * Depend on all deps collected by this watcher. 6700 */ 6701Watcher.prototype.depend = function depend () { 6702 var i = this.deps.length; 6703 while (i--) { 6704 this.deps[i].depend(); 6705 } 6706}; 6707 6708/** 6709 * Remove self from all dependencies' subscriber list. 6710 */ 6711Watcher.prototype.teardown = function teardown () { 6712 if (this.active) { 6713 // remove self from vm's watcher list 6714 // this is a somewhat expensive operation so we skip it 6715 // if the vm is being destroyed. 6716 if (!this.vm._isBeingDestroyed) { 6717 remove(this.vm._watchers, this); 6718 } 6719 var i = this.deps.length; 6720 while (i--) { 6721 this.deps[i].removeSub(this); 6722 } 6723 this.active = false; 6724 } 6725}; 6726 6727/* */ 6728 6729var sharedPropertyDefinition = { 6730 enumerable: true, 6731 configurable: true, 6732 get: noop, 6733 set: noop 6734}; 6735 6736function proxy (target, sourceKey, key) { 6737 sharedPropertyDefinition.get = function proxyGetter () { 6738 return this[sourceKey][key] 6739 }; 6740 sharedPropertyDefinition.set = function proxySetter (val) { 6741 this[sourceKey][key] = val; 6742 }; 6743 Object.defineProperty(target, key, sharedPropertyDefinition); 6744} 6745 6746function initState (vm) { 6747 vm._watchers = []; 6748 var opts = vm.$options; 6749 if (opts.props) { initProps(vm, opts.props); } 6750 if (opts.methods) { initMethods(vm, opts.methods); } 6751 if (opts.data) { 6752 initData(vm); 6753 } else { 6754 observe(vm._data = {}, true /* asRootData */); 6755 } 6756 if (opts.computed) { initComputed(vm, opts.computed); } 6757 if (opts.watch && opts.watch !== nativeWatch) { 6758 initWatch(vm, opts.watch); 6759 } 6760} 6761 6762function initProps (vm, propsOptions) { 6763 var propsData = vm.$options.propsData || {}; 6764 var props = vm._props = {}; 6765 // cache prop keys so that future props updates can iterate using Array 6766 // instead of dynamic object key enumeration. 6767 var keys = vm.$options._propKeys = []; 6768 var isRoot = !vm.$parent; 6769 // root instance props should be converted 6770 if (!isRoot) { 6771 toggleObserving(false); 6772 } 6773 var loop = function ( key ) { 6774 keys.push(key); 6775 var value = validateProp(key, propsOptions, propsData, vm); 6776 /* istanbul ignore else */ 6777 { 6778 var hyphenatedKey = hyphenate(key); 6779 if (isReservedAttribute(hyphenatedKey) || 6780 config.isReservedAttr(hyphenatedKey)) { 6781 warn( 6782 ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), 6783 vm 6784 ); 6785 } 6786 defineReactive$$1(props, key, value, function () { 6787 if (!isRoot && !isUpdatingChildComponent) { 6788 warn( 6789 "Avoid mutating a prop directly since the value will be " + 6790 "overwritten whenever the parent component re-renders. " + 6791 "Instead, use a data or computed property based on the prop's " + 6792 "value. Prop being mutated: \"" + key + "\"", 6793 vm 6794 ); 6795 } 6796 }); 6797 } 6798 // static props are already proxied on the component's prototype 6799 // during Vue.extend(). We only need to proxy props defined at 6800 // instantiation here. 6801 if (!(key in vm)) { 6802 proxy(vm, "_props", key); 6803 } 6804 }; 6805 6806 for (var key in propsOptions) loop( key ); 6807 toggleObserving(true); 6808} 6809 6810function initData (vm) { 6811 var data = vm.$options.data; 6812 data = vm._data = typeof data === 'function' 6813 ? getData(data, vm) 6814 : data || {}; 6815 if (!isPlainObject(data)) { 6816 data = {}; 6817 warn( 6818 'data functions should return an object:\n' + 6819 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', 6820 vm 6821 ); 6822 } 6823 // proxy data on instance 6824 var keys = Object.keys(data); 6825 var props = vm.$options.props; 6826 var methods = vm.$options.methods; 6827 var i = keys.length; 6828 while (i--) { 6829 var key = keys[i]; 6830 { 6831 if (methods && hasOwn(methods, key)) { 6832 warn( 6833 ("Method \"" + key + "\" has already been defined as a data property."), 6834 vm 6835 ); 6836 } 6837 } 6838 if (props && hasOwn(props, key)) { 6839 warn( 6840 "The data property \"" + key + "\" is already declared as a prop. " + 6841 "Use prop default value instead.", 6842 vm 6843 ); 6844 } else if (!isReserved(key)) { 6845 proxy(vm, "_data", key); 6846 } 6847 } 6848 // observe data 6849 observe(data, true /* asRootData */); 6850} 6851 6852function getData (data, vm) { 6853 // #7573 disable dep collection when invoking data getters 6854 pushTarget(); 6855 try { 6856 return data.call(vm, vm) 6857 } catch (e) { 6858 handleError(e, vm, "data()"); 6859 return {} 6860 } finally { 6861 popTarget(); 6862 } 6863} 6864 6865var computedWatcherOptions = { lazy: true }; 6866 6867function initComputed (vm, computed) { 6868 // $flow-disable-line 6869 var watchers = vm._computedWatchers = Object.create(null); 6870 // computed properties are just getters during SSR 6871 var isSSR = isServerRendering(); 6872 6873 for (var key in computed) { 6874 var userDef = computed[key]; 6875 var getter = typeof userDef === 'function' ? userDef : userDef.get; 6876 if (getter == null) { 6877 warn( 6878 ("Getter is missing for computed property \"" + key + "\"."), 6879 vm 6880 ); 6881 } 6882 6883 if (!isSSR) { 6884 // create internal watcher for the computed property. 6885 watchers[key] = new Watcher( 6886 vm, 6887 getter || noop, 6888 noop, 6889 computedWatcherOptions 6890 ); 6891 } 6892 6893 // component-defined computed properties are already defined on the 6894 // component prototype. We only need to define computed properties defined 6895 // at instantiation here. 6896 if (!(key in vm)) { 6897 defineComputed(vm, key, userDef); 6898 } else { 6899 if (key in vm.$data) { 6900 warn(("The computed property \"" + key + "\" is already defined in data."), vm); 6901 } else if (vm.$options.props && key in vm.$options.props) { 6902 warn(("The computed property \"" + key + "\" is already defined as a prop."), vm); 6903 } else if (vm.$options.methods && key in vm.$options.methods) { 6904 warn(("The computed property \"" + key + "\" is already defined as a method."), vm); 6905 } 6906 } 6907 } 6908} 6909 6910function defineComputed ( 6911 target, 6912 key, 6913 userDef 6914) { 6915 var shouldCache = !isServerRendering(); 6916 if (typeof userDef === 'function') { 6917 sharedPropertyDefinition.get = shouldCache 6918 ? createComputedGetter(key) 6919 : createGetterInvoker(userDef); 6920 sharedPropertyDefinition.set = noop; 6921 } else { 6922 sharedPropertyDefinition.get = userDef.get 6923 ? shouldCache && userDef.cache !== false 6924 ? createComputedGetter(key) 6925 : createGetterInvoker(userDef.get) 6926 : noop; 6927 sharedPropertyDefinition.set = userDef.set || noop; 6928 } 6929 if (sharedPropertyDefinition.set === noop) { 6930 sharedPropertyDefinition.set = function () { 6931 warn( 6932 ("Computed property \"" + key + "\" was assigned to but it has no setter."), 6933 this 6934 ); 6935 }; 6936 } 6937 Object.defineProperty(target, key, sharedPropertyDefinition); 6938} 6939 6940function createComputedGetter (key) { 6941 return function computedGetter () { 6942 var watcher = this._computedWatchers && this._computedWatchers[key]; 6943 if (watcher) { 6944 if (watcher.dirty) { 6945 watcher.evaluate(); 6946 } 6947 if (Dep.target) { 6948 watcher.depend(); 6949 } 6950 return watcher.value 6951 } 6952 } 6953} 6954 6955function createGetterInvoker(fn) { 6956 return function computedGetter () { 6957 return fn.call(this, this) 6958 } 6959} 6960 6961function initMethods (vm, methods) { 6962 var props = vm.$options.props; 6963 for (var key in methods) { 6964 { 6965 if (typeof methods[key] !== 'function') { 6966 warn( 6967 "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " + 6968 "Did you reference the function correctly?", 6969 vm 6970 ); 6971 } 6972 if (props && hasOwn(props, key)) { 6973 warn( 6974 ("Method \"" + key + "\" has already been defined as a prop."), 6975 vm 6976 ); 6977 } 6978 if ((key in vm) && isReserved(key)) { 6979 warn( 6980 "Method \"" + key + "\" conflicts with an existing Vue instance method. " + 6981 "Avoid defining component methods that start with _ or $." 6982 ); 6983 } 6984 } 6985 vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm); 6986 } 6987} 6988 6989function initWatch (vm, watch) { 6990 for (var key in watch) { 6991 var handler = watch[key]; 6992 if (Array.isArray(handler)) { 6993 for (var i = 0; i < handler.length; i++) { 6994 createWatcher(vm, key, handler[i]); 6995 } 6996 } else { 6997 createWatcher(vm, key, handler); 6998 } 6999 } 7000} 7001 7002function createWatcher ( 7003 vm, 7004 expOrFn, 7005 handler, 7006 options 7007) { 7008 if (isPlainObject(handler)) { 7009 options = handler; 7010 handler = handler.handler; 7011 } 7012 if (typeof handler === 'string') { 7013 handler = vm[handler]; 7014 } 7015 return vm.$watch(expOrFn, handler, options) 7016} 7017 7018function stateMixin (Vue) { 7019 // flow somehow has problems with directly declared definition object 7020 // when using Object.defineProperty, so we have to procedurally build up 7021 // the object here. 7022 var dataDef = {}; 7023 dataDef.get = function () { return this._data }; 7024 var propsDef = {}; 7025 propsDef.get = function () { return this._props }; 7026 { 7027 dataDef.set = function () { 7028 warn( 7029 'Avoid replacing instance root $data. ' + 7030 'Use nested data properties instead.', 7031 this 7032 ); 7033 }; 7034 propsDef.set = function () { 7035 warn("$props is readonly.", this); 7036 }; 7037 } 7038 Object.defineProperty(Vue.prototype, '$data', dataDef); 7039 Object.defineProperty(Vue.prototype, '$props', propsDef); 7040 7041 Vue.prototype.$set = set; 7042 Vue.prototype.$delete = del; 7043 7044 Vue.prototype.$watch = function ( 7045 expOrFn, 7046 cb, 7047 options 7048 ) { 7049 var vm = this; 7050 if (isPlainObject(cb)) { 7051 return createWatcher(vm, expOrFn, cb, options) 7052 } 7053 options = options || {}; 7054 options.user = true; 7055 var watcher = new Watcher(vm, expOrFn, cb, options); 7056 if (options.immediate) { 7057 var info = "callback for immediate watcher \"" + (watcher.expression) + "\""; 7058 pushTarget(); 7059 invokeWithErrorHandling(cb, vm, [watcher.value], vm, info); 7060 popTarget(); 7061 } 7062 return function unwatchFn () { 7063 watcher.teardown(); 7064 } 7065 }; 7066} 7067 7068/* */ 7069 7070var uid$3 = 0; 7071 7072function initMixin (Vue) { 7073 Vue.prototype._init = function (options) { 7074 var vm = this; 7075 // a uid 7076 vm._uid = uid$3++; 7077 7078 var startTag, endTag; 7079 /* istanbul ignore if */ 7080 if (config.performance && mark) { 7081 startTag = "vue-perf-start:" + (vm._uid); 7082 endTag = "vue-perf-end:" + (vm._uid); 7083 mark(startTag); 7084 } 7085 7086 // a flag to avoid this being observed 7087 vm._isVue = true; 7088 // merge options 7089 if (options && options._isComponent) { 7090 // optimize internal component instantiation 7091 // since dynamic options merging is pretty slow, and none of the 7092 // internal component options needs special treatment. 7093 initInternalComponent(vm, options); 7094 } else { 7095 vm.$options = mergeOptions( 7096 resolveConstructorOptions(vm.constructor), 7097 options || {}, 7098 vm 7099 ); 7100 } 7101 /* istanbul ignore else */ 7102 { 7103 initProxy(vm); 7104 } 7105 // expose real self 7106 vm._self = vm; 7107 initLifecycle(vm); 7108 initEvents(vm); 7109 initRender(vm); 7110 callHook(vm, 'beforeCreate'); 7111 initInjections(vm); // resolve injections before data/props 7112 initState(vm); 7113 initProvide(vm); // resolve provide after data/props 7114 callHook(vm, 'created'); 7115 7116 /* istanbul ignore if */ 7117 if (config.performance && mark) { 7118 vm._name = formatComponentName(vm, false); 7119 mark(endTag); 7120 measure(("vue " + (vm._name) + " init"), startTag, endTag); 7121 } 7122 7123 if (vm.$options.el) { 7124 vm.$mount(vm.$options.el); 7125 } 7126 }; 7127} 7128 7129function initInternalComponent (vm, options) { 7130 var opts = vm.$options = Object.create(vm.constructor.options); 7131 // doing this because it's faster than dynamic enumeration. 7132 var parentVnode = options._parentVnode; 7133 opts.parent = options.parent; 7134 opts._parentVnode = parentVnode; 7135 7136 var vnodeComponentOptions = parentVnode.componentOptions; 7137 opts.propsData = vnodeComponentOptions.propsData; 7138 opts._parentListeners = vnodeComponentOptions.listeners; 7139 opts._renderChildren = vnodeComponentOptions.children; 7140 opts._componentTag = vnodeComponentOptions.tag; 7141 7142 if (options.render) { 7143 opts.render = options.render; 7144 opts.staticRenderFns = options.staticRenderFns; 7145 } 7146} 7147 7148function resolveConstructorOptions (Ctor) { 7149 var options = Ctor.options; 7150 if (Ctor.super) { 7151 var superOptions = resolveConstructorOptions(Ctor.super); 7152 var cachedSuperOptions = Ctor.superOptions; 7153 if (superOptions !== cachedSuperOptions) { 7154 // super option changed, 7155 // need to resolve new options. 7156 Ctor.superOptions = superOptions; 7157 // check if there are any late-modified/attached options (#4976) 7158 var modifiedOptions = resolveModifiedOptions(Ctor); 7159 // update base extend options 7160 if (modifiedOptions) { 7161 extend(Ctor.extendOptions, modifiedOptions); 7162 } 7163 options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); 7164 if (options.name) { 7165 options.components[options.name] = Ctor; 7166 } 7167 } 7168 } 7169 return options 7170} 7171 7172function resolveModifiedOptions (Ctor) { 7173 var modified; 7174 var latest = Ctor.options; 7175 var sealed = Ctor.sealedOptions; 7176 for (var key in latest) { 7177 if (latest[key] !== sealed[key]) { 7178 if (!modified) { modified = {}; } 7179 modified[key] = latest[key]; 7180 } 7181 } 7182 return modified 7183} 7184 7185function Vue (options) { 7186 if (!(this instanceof Vue) 7187 ) { 7188 warn('Vue is a constructor and should be called with the `new` keyword'); 7189 } 7190 this._init(options); 7191} 7192 7193initMixin(Vue); 7194stateMixin(Vue); 7195eventsMixin(Vue); 7196lifecycleMixin(Vue); 7197renderMixin(Vue); 7198 7199/* */ 7200 7201function initUse (Vue) { 7202 Vue.use = function (plugin) { 7203 var installedPlugins = (this._installedPlugins || (this._installedPlugins = [])); 7204 if (installedPlugins.indexOf(plugin) > -1) { 7205 return this 7206 } 7207 7208 // additional parameters 7209 var args = toArray(arguments, 1); 7210 args.unshift(this); 7211 if (typeof plugin.install === 'function') { 7212 plugin.install.apply(plugin, args); 7213 } else if (typeof plugin === 'function') { 7214 plugin.apply(null, args); 7215 } 7216 installedPlugins.push(plugin); 7217 return this 7218 }; 7219} 7220 7221/* */ 7222 7223function initMixin$1 (Vue) { 7224 Vue.mixin = function (mixin) { 7225 this.options = mergeOptions(this.options, mixin); 7226 return this 7227 }; 7228} 7229 7230/* */ 7231 7232function initExtend (Vue) { 7233 /** 7234 * Each instance constructor, including Vue, has a unique 7235 * cid. This enables us to create wrapped "child 7236 * constructors" for prototypal inheritance and cache them. 7237 */ 7238 Vue.cid = 0; 7239 var cid = 1; 7240 7241 /** 7242 * Class inheritance 7243 */ 7244 Vue.extend = function (extendOptions) { 7245 extendOptions = extendOptions || {}; 7246 var Super = this; 7247 var SuperId = Super.cid; 7248 var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); 7249 if (cachedCtors[SuperId]) { 7250 return cachedCtors[SuperId] 7251 } 7252 7253 var name = extendOptions.name || Super.options.name; 7254 if (name) { 7255 validateComponentName(name); 7256 } 7257 7258 var Sub = function VueComponent (options) { 7259 this._init(options); 7260 }; 7261 Sub.prototype = Object.create(Super.prototype); 7262 Sub.prototype.constructor = Sub; 7263 Sub.cid = cid++; 7264 Sub.options = mergeOptions( 7265 Super.options, 7266 extendOptions 7267 ); 7268 Sub['super'] = Super; 7269 7270 // For props and computed properties, we define the proxy getters on 7271 // the Vue instances at extension time, on the extended prototype. This 7272 // avoids Object.defineProperty calls for each instance created. 7273 if (Sub.options.props) { 7274 initProps$1(Sub); 7275 } 7276 if (Sub.options.computed) { 7277 initComputed$1(Sub); 7278 } 7279 7280 // allow further extension/mixin/plugin usage 7281 Sub.extend = Super.extend; 7282 Sub.mixin = Super.mixin; 7283 Sub.use = Super.use; 7284 7285 // create asset registers, so extended classes 7286 // can have their private assets too. 7287 ASSET_TYPES.forEach(function (type) { 7288 Sub[type] = Super[type]; 7289 }); 7290 // enable recursive self-lookup 7291 if (name) { 7292 Sub.options.components[name] = Sub; 7293 } 7294 7295 // keep a reference to the super options at extension time. 7296 // later at instantiation we can check if Super's options have 7297 // been updated. 7298 Sub.superOptions = Super.options; 7299 Sub.extendOptions = extendOptions; 7300 Sub.sealedOptions = extend({}, Sub.options); 7301 7302 // cache constructor 7303 cachedCtors[SuperId] = Sub; 7304 return Sub 7305 }; 7306} 7307 7308function initProps$1 (Comp) { 7309 var props = Comp.options.props; 7310 for (var key in props) { 7311 proxy(Comp.prototype, "_props", key); 7312 } 7313} 7314 7315function initComputed$1 (Comp) { 7316 var computed = Comp.options.computed; 7317 for (var key in computed) { 7318 defineComputed(Comp.prototype, key, computed[key]); 7319 } 7320} 7321 7322/* */ 7323 7324function initAssetRegisters (Vue) { 7325 /** 7326 * Create asset registration methods. 7327 */ 7328 ASSET_TYPES.forEach(function (type) { 7329 Vue[type] = function ( 7330 id, 7331 definition 7332 ) { 7333 if (!definition) { 7334 return this.options[type + 's'][id] 7335 } else { 7336 /* istanbul ignore if */ 7337 if (type === 'component') { 7338 validateComponentName(id); 7339 } 7340 if (type === 'component' && isPlainObject(definition)) { 7341 definition.name = definition.name || id; 7342 definition = this.options._base.extend(definition); 7343 } 7344 if (type === 'directive' && typeof definition === 'function') { 7345 definition = { bind: definition, update: definition }; 7346 } 7347 this.options[type + 's'][id] = definition; 7348 return definition 7349 } 7350 }; 7351 }); 7352} 7353 7354/* */ 7355 7356 7357 7358 7359 7360function getComponentName (opts) { 7361 return opts && (opts.Ctor.options.name || opts.tag) 7362} 7363 7364function matches (pattern, name) { 7365 if (Array.isArray(pattern)) { 7366 return pattern.indexOf(name) > -1 7367 } else if (typeof pattern === 'string') { 7368 return pattern.split(',').indexOf(name) > -1 7369 } else if (isRegExp(pattern)) { 7370 return pattern.test(name) 7371 } 7372 /* istanbul ignore next */ 7373 return false 7374} 7375 7376function pruneCache (keepAliveInstance, filter) { 7377 var cache = keepAliveInstance.cache; 7378 var keys = keepAliveInstance.keys; 7379 var _vnode = keepAliveInstance._vnode; 7380 for (var key in cache) { 7381 var entry = cache[key]; 7382 if (entry) { 7383 var name = entry.name; 7384 if (name && !filter(name)) { 7385 pruneCacheEntry(cache, key, keys, _vnode); 7386 } 7387 } 7388 } 7389} 7390 7391function pruneCacheEntry ( 7392 cache, 7393 key, 7394 keys, 7395 current 7396) { 7397 var entry = cache[key]; 7398 if (entry && (!current || entry.tag !== current.tag)) { 7399 entry.componentInstance.$destroy(); 7400 } 7401 cache[key] = null; 7402 remove(keys, key); 7403} 7404 7405var patternTypes = [String, RegExp, Array]; 7406 7407var KeepAlive = { 7408 name: 'keep-alive', 7409 abstract: true, 7410 7411 props: { 7412 include: patternTypes, 7413 exclude: patternTypes, 7414 max: [String, Number] 7415 }, 7416 7417 methods: { 7418 cacheVNode: function cacheVNode() { 7419 var ref = this; 7420 var cache = ref.cache; 7421 var keys = ref.keys; 7422 var vnodeToCache = ref.vnodeToCache; 7423 var keyToCache = ref.keyToCache; 7424 if (vnodeToCache) { 7425 var tag = vnodeToCache.tag; 7426 var componentInstance = vnodeToCache.componentInstance; 7427 var componentOptions = vnodeToCache.componentOptions; 7428 cache[keyToCache] = { 7429 name: getComponentName(componentOptions), 7430 tag: tag, 7431 componentInstance: componentInstance, 7432 }; 7433 keys.push(keyToCache); 7434 // prune oldest entry 7435 if (this.max && keys.length > parseInt(this.max)) { 7436 pruneCacheEntry(cache, keys[0], keys, this._vnode); 7437 } 7438 this.vnodeToCache = null; 7439 } 7440 } 7441 }, 7442 7443 created: function created () { 7444 this.cache = Object.create(null); 7445 this.keys = []; 7446 }, 7447 7448 destroyed: function destroyed () { 7449 for (var key in this.cache) { 7450 pruneCacheEntry(this.cache, key, this.keys); 7451 } 7452 }, 7453 7454 mounted: function mounted () { 7455 var this$1 = this; 7456 7457 this.cacheVNode(); 7458 this.$watch('include', function (val) { 7459 pruneCache(this$1, function (name) { return matches(val, name); }); 7460 }); 7461 this.$watch('exclude', function (val) { 7462 pruneCache(this$1, function (name) { return !matches(val, name); }); 7463 }); 7464 }, 7465 7466 updated: function updated () { 7467 this.cacheVNode(); 7468 }, 7469 7470 render: function render () { 7471 var slot = this.$slots.default; 7472 var vnode = getFirstComponentChild(slot); 7473 var componentOptions = vnode && vnode.componentOptions; 7474 if (componentOptions) { 7475 // check pattern 7476 var name = getComponentName(componentOptions); 7477 var ref = this; 7478 var include = ref.include; 7479 var exclude = ref.exclude; 7480 if ( 7481 // not included 7482 (include && (!name || !matches(include, name))) || 7483 // excluded 7484 (exclude && name && matches(exclude, name)) 7485 ) { 7486 return vnode 7487 } 7488 7489 var ref$1 = this; 7490 var cache = ref$1.cache; 7491 var keys = ref$1.keys; 7492 var key = vnode.key == null 7493 // same constructor may get registered as different local components 7494 // so cid alone is not enough (#3269) 7495 ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '') 7496 : vnode.key; 7497 if (cache[key]) { 7498 vnode.componentInstance = cache[key].componentInstance; 7499 // make current key freshest 7500 remove(keys, key); 7501 keys.push(key); 7502 } else { 7503 // delay setting the cache until update 7504 this.vnodeToCache = vnode; 7505 this.keyToCache = key; 7506 } 7507 7508 vnode.data.keepAlive = true; 7509 } 7510 return vnode || (slot && slot[0]) 7511 } 7512}; 7513 7514var builtInComponents = { 7515 KeepAlive: KeepAlive 7516}; 7517 7518/* */ 7519 7520function initGlobalAPI (Vue) { 7521 // config 7522 var configDef = {}; 7523 configDef.get = function () { return config; }; 7524 { 7525 configDef.set = function () { 7526 warn( 7527 'Do not replace the Vue.config object, set individual fields instead.' 7528 ); 7529 }; 7530 } 7531 Object.defineProperty(Vue, 'config', configDef); 7532 7533 // exposed util methods. 7534 // NOTE: these are not considered part of the public API - avoid relying on 7535 // them unless you are aware of the risk. 7536 Vue.util = { 7537 warn: warn, 7538 extend: extend, 7539 mergeOptions: mergeOptions, 7540 defineReactive: defineReactive$$1 7541 }; 7542 7543 Vue.set = set; 7544 Vue.delete = del; 7545 Vue.nextTick = nextTick; 7546 7547 // 2.6 explicit observable API 7548 Vue.observable = function (obj) { 7549 observe(obj); 7550 return obj 7551 }; 7552 7553 Vue.options = Object.create(null); 7554 ASSET_TYPES.forEach(function (type) { 7555 Vue.options[type + 's'] = Object.create(null); 7556 }); 7557 7558 // this is used to identify the "base" constructor to extend all plain-object 7559 // components with in Weex's multi-instance scenarios. 7560 Vue.options._base = Vue; 7561 7562 extend(Vue.options.components, builtInComponents); 7563 7564 initUse(Vue); 7565 initMixin$1(Vue); 7566 initExtend(Vue); 7567 initAssetRegisters(Vue); 7568} 7569 7570initGlobalAPI(Vue); 7571 7572Object.defineProperty(Vue.prototype, '$isServer', { 7573 get: isServerRendering 7574}); 7575 7576Object.defineProperty(Vue.prototype, '$ssrContext', { 7577 get: function get () { 7578 /* istanbul ignore next */ 7579 return this.$vnode && this.$vnode.ssrContext 7580 } 7581}); 7582 7583// expose FunctionalRenderContext for ssr runtime helper installation 7584Object.defineProperty(Vue, 'FunctionalRenderContext', { 7585 value: FunctionalRenderContext 7586}); 7587 7588Vue.version = '2.6.14'; 7589 7590/* */ 7591 7592// these are reserved for web because they are directly compiled away 7593// during template compilation 7594var isReservedAttr = makeMap('style,class'); 7595 7596// attributes that should be using props for binding 7597var acceptValue = makeMap('input,textarea,option,select,progress'); 7598var mustUseProp = function (tag, type, attr) { 7599 return ( 7600 (attr === 'value' && acceptValue(tag)) && type !== 'button' || 7601 (attr === 'selected' && tag === 'option') || 7602 (attr === 'checked' && tag === 'input') || 7603 (attr === 'muted' && tag === 'video') 7604 ) 7605}; 7606 7607var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); 7608 7609var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only'); 7610 7611var convertEnumeratedValue = function (key, value) { 7612 return isFalsyAttrValue(value) || value === 'false' 7613 ? 'false' 7614 // allow arbitrary string value for contenteditable 7615 : key === 'contenteditable' && isValidContentEditableValue(value) 7616 ? value 7617 : 'true' 7618}; 7619 7620var isBooleanAttr = makeMap( 7621 'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 7622 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 7623 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 7624 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 7625 'required,reversed,scoped,seamless,selected,sortable,' + 7626 'truespeed,typemustmatch,visible' 7627); 7628 7629var xlinkNS = 'http://www.w3.org/1999/xlink'; 7630 7631var isXlink = function (name) { 7632 return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink' 7633}; 7634 7635var getXlinkProp = function (name) { 7636 return isXlink(name) ? name.slice(6, name.length) : '' 7637}; 7638 7639var isFalsyAttrValue = function (val) { 7640 return val == null || val === false 7641}; 7642 7643/* */ 7644 7645function genClassForVnode (vnode) { 7646 var data = vnode.data; 7647 var parentNode = vnode; 7648 var childNode = vnode; 7649 while (isDef(childNode.componentInstance)) { 7650 childNode = childNode.componentInstance._vnode; 7651 if (childNode && childNode.data) { 7652 data = mergeClassData(childNode.data, data); 7653 } 7654 } 7655 while (isDef(parentNode = parentNode.parent)) { 7656 if (parentNode && parentNode.data) { 7657 data = mergeClassData(data, parentNode.data); 7658 } 7659 } 7660 return renderClass(data.staticClass, data.class) 7661} 7662 7663function mergeClassData (child, parent) { 7664 return { 7665 staticClass: concat(child.staticClass, parent.staticClass), 7666 class: isDef(child.class) 7667 ? [child.class, parent.class] 7668 : parent.class 7669 } 7670} 7671 7672function renderClass ( 7673 staticClass, 7674 dynamicClass 7675) { 7676 if (isDef(staticClass) || isDef(dynamicClass)) { 7677 return concat(staticClass, stringifyClass(dynamicClass)) 7678 } 7679 /* istanbul ignore next */ 7680 return '' 7681} 7682 7683function concat (a, b) { 7684 return a ? b ? (a + ' ' + b) : a : (b || '') 7685} 7686 7687function stringifyClass (value) { 7688 if (Array.isArray(value)) { 7689 return stringifyArray(value) 7690 } 7691 if (isObject(value)) { 7692 return stringifyObject(value) 7693 } 7694 if (typeof value === 'string') { 7695 return value 7696 } 7697 /* istanbul ignore next */ 7698 return '' 7699} 7700 7701function stringifyArray (value) { 7702 var res = ''; 7703 var stringified; 7704 for (var i = 0, l = value.length; i < l; i++) { 7705 if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') { 7706 if (res) { res += ' '; } 7707 res += stringified; 7708 } 7709 } 7710 return res 7711} 7712 7713function stringifyObject (value) { 7714 var res = ''; 7715 for (var key in value) { 7716 if (value[key]) { 7717 if (res) { res += ' '; } 7718 res += key; 7719 } 7720 } 7721 return res 7722} 7723 7724/* */ 7725 7726var namespaceMap = { 7727 svg: 'http://www.w3.org/2000/svg', 7728 math: 'http://www.w3.org/1998/Math/MathML' 7729}; 7730 7731var isHTMLTag = makeMap( 7732 'html,body,base,head,link,meta,style,title,' + 7733 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 7734 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 7735 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 7736 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 7737 'embed,object,param,source,canvas,script,noscript,del,ins,' + 7738 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 7739 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 7740 'output,progress,select,textarea,' + 7741 'details,dialog,menu,menuitem,summary,' + 7742 'content,element,shadow,template,blockquote,iframe,tfoot' 7743); 7744 7745// this map is intentionally selective, only covering SVG elements that may 7746// contain child elements. 7747var isSVG = makeMap( 7748 'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 7749 'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 7750 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', 7751 true 7752); 7753 7754var isPreTag = function (tag) { return tag === 'pre'; }; 7755 7756var isReservedTag = function (tag) { 7757 return isHTMLTag(tag) || isSVG(tag) 7758}; 7759 7760function getTagNamespace (tag) { 7761 if (isSVG(tag)) { 7762 return 'svg' 7763 } 7764 // basic support for MathML 7765 // note it doesn't support other MathML elements being component roots 7766 if (tag === 'math') { 7767 return 'math' 7768 } 7769} 7770 7771var unknownElementCache = Object.create(null); 7772function isUnknownElement (tag) { 7773 /* istanbul ignore if */ 7774 if (!inBrowser) { 7775 return true 7776 } 7777 if (isReservedTag(tag)) { 7778 return false 7779 } 7780 tag = tag.toLowerCase(); 7781 /* istanbul ignore if */ 7782 if (unknownElementCache[tag] != null) { 7783 return unknownElementCache[tag] 7784 } 7785 var el = document.createElement(tag); 7786 if (tag.indexOf('-') > -1) { 7787 // http://stackoverflow.com/a/28210364/1070244 7788 return (unknownElementCache[tag] = ( 7789 el.constructor === window.HTMLUnknownElement || 7790 el.constructor === window.HTMLElement 7791 )) 7792 } else { 7793 return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString())) 7794 } 7795} 7796 7797var isTextInputType = makeMap('text,number,password,search,email,tel,url'); 7798 7799/* */ 7800 7801/** 7802 * Query an element selector if it's not an element already. 7803 */ 7804function query (el) { 7805 if (typeof el === 'string') { 7806 var selected = document.querySelector(el); 7807 if (!selected) { 7808 warn( 7809 'Cannot find element: ' + el 7810 ); 7811 return document.createElement('div') 7812 } 7813 return selected 7814 } else { 7815 return el 7816 } 7817} 7818 7819/* */ 7820 7821function createElement$1 (tagName, vnode) { 7822 var elm = document.createElement(tagName); 7823 if (tagName !== 'select') { 7824 return elm 7825 } 7826 // false or null will remove the attribute but undefined will not 7827 if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) { 7828 elm.setAttribute('multiple', 'multiple'); 7829 } 7830 return elm 7831} 7832 7833function createElementNS (namespace, tagName) { 7834 return document.createElementNS(namespaceMap[namespace], tagName) 7835} 7836 7837function createTextNode (text) { 7838 return document.createTextNode(text) 7839} 7840 7841function createComment (text) { 7842 return document.createComment(text) 7843} 7844 7845function insertBefore (parentNode, newNode, referenceNode) { 7846 parentNode.insertBefore(newNode, referenceNode); 7847} 7848 7849function removeChild (node, child) { 7850 node.removeChild(child); 7851} 7852 7853function appendChild (node, child) { 7854 node.appendChild(child); 7855} 7856 7857function parentNode (node) { 7858 return node.parentNode 7859} 7860 7861function nextSibling (node) { 7862 return node.nextSibling 7863} 7864 7865function tagName (node) { 7866 return node.tagName 7867} 7868 7869function setTextContent (node, text) { 7870 node.textContent = text; 7871} 7872 7873function setStyleScope (node, scopeId) { 7874 node.setAttribute(scopeId, ''); 7875} 7876 7877var nodeOps = /*#__PURE__*/Object.freeze({ 7878 createElement: createElement$1, 7879 createElementNS: createElementNS, 7880 createTextNode: createTextNode, 7881 createComment: createComment, 7882 insertBefore: insertBefore, 7883 removeChild: removeChild, 7884 appendChild: appendChild, 7885 parentNode: parentNode, 7886 nextSibling: nextSibling, 7887 tagName: tagName, 7888 setTextContent: setTextContent, 7889 setStyleScope: setStyleScope 7890}); 7891 7892/* */ 7893 7894var ref = { 7895 create: function create (_, vnode) { 7896 registerRef(vnode); 7897 }, 7898 update: function update (oldVnode, vnode) { 7899 if (oldVnode.data.ref !== vnode.data.ref) { 7900 registerRef(oldVnode, true); 7901 registerRef(vnode); 7902 } 7903 }, 7904 destroy: function destroy (vnode) { 7905 registerRef(vnode, true); 7906 } 7907}; 7908 7909function registerRef (vnode, isRemoval) { 7910 var key = vnode.data.ref; 7911 if (!isDef(key)) { return } 7912 7913 var vm = vnode.context; 7914 var ref = vnode.componentInstance || vnode.elm; 7915 var refs = vm.$refs; 7916 if (isRemoval) { 7917 if (Array.isArray(refs[key])) { 7918 remove(refs[key], ref); 7919 } else if (refs[key] === ref) { 7920 refs[key] = undefined; 7921 } 7922 } else { 7923 if (vnode.data.refInFor) { 7924 if (!Array.isArray(refs[key])) { 7925 refs[key] = [ref]; 7926 } else if (refs[key].indexOf(ref) < 0) { 7927 // $flow-disable-line 7928 refs[key].push(ref); 7929 } 7930 } else { 7931 refs[key] = ref; 7932 } 7933 } 7934} 7935 7936/** 7937 * Virtual DOM patching algorithm based on Snabbdom by 7938 * Simon Friis Vindum (@paldepind) 7939 * Licensed under the MIT License 7940 * https://github.com/paldepind/snabbdom/blob/master/LICENSE 7941 * 7942 * modified by Evan You (@yyx990803) 7943 * 7944 * Not type-checking this because this file is perf-critical and the cost 7945 * of making flow understand it is not worth it. 7946 */ 7947 7948var emptyNode = new VNode('', {}, []); 7949 7950var hooks = ['create', 'activate', 'update', 'remove', 'destroy']; 7951 7952function sameVnode (a, b) { 7953 return ( 7954 a.key === b.key && 7955 a.asyncFactory === b.asyncFactory && ( 7956 ( 7957 a.tag === b.tag && 7958 a.isComment === b.isComment && 7959 isDef(a.data) === isDef(b.data) && 7960 sameInputType(a, b) 7961 ) || ( 7962 isTrue(a.isAsyncPlaceholder) && 7963 isUndef(b.asyncFactory.error) 7964 ) 7965 ) 7966 ) 7967} 7968 7969function sameInputType (a, b) { 7970 if (a.tag !== 'input') { return true } 7971 var i; 7972 var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; 7973 var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; 7974 return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB) 7975} 7976 7977function createKeyToOldIdx (children, beginIdx, endIdx) { 7978 var i, key; 7979 var map = {}; 7980 for (i = beginIdx; i <= endIdx; ++i) { 7981 key = children[i].key; 7982 if (isDef(key)) { map[key] = i; } 7983 } 7984 return map 7985} 7986 7987function createPatchFunction (backend) { 7988 var i, j; 7989 var cbs = {}; 7990 7991 var modules = backend.modules; 7992 var nodeOps = backend.nodeOps; 7993 7994 for (i = 0; i < hooks.length; ++i) { 7995 cbs[hooks[i]] = []; 7996 for (j = 0; j < modules.length; ++j) { 7997 if (isDef(modules[j][hooks[i]])) { 7998 cbs[hooks[i]].push(modules[j][hooks[i]]); 7999 } 8000 } 8001 } 8002 8003 function emptyNodeAt (elm) { 8004 return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm) 8005 } 8006 8007 function createRmCb (childElm, listeners) { 8008 function remove$$1 () { 8009 if (--remove$$1.listeners === 0) { 8010 removeNode(childElm); 8011 } 8012 } 8013 remove$$1.listeners = listeners; 8014 return remove$$1 8015 } 8016 8017 function removeNode (el) { 8018 var parent = nodeOps.parentNode(el); 8019 // element may have already been removed due to v-html / v-text 8020 if (isDef(parent)) { 8021 nodeOps.removeChild(parent, el); 8022 } 8023 } 8024 8025 function isUnknownElement$$1 (vnode, inVPre) { 8026 return ( 8027 !inVPre && 8028 !vnode.ns && 8029 !( 8030 config.ignoredElements.length && 8031 config.ignoredElements.some(function (ignore) { 8032 return isRegExp(ignore) 8033 ? ignore.test(vnode.tag) 8034 : ignore === vnode.tag 8035 }) 8036 ) && 8037 config.isUnknownElement(vnode.tag) 8038 ) 8039 } 8040 8041 var creatingElmInVPre = 0; 8042 8043 function createElm ( 8044 vnode, 8045 insertedVnodeQueue, 8046 parentElm, 8047 refElm, 8048 nested, 8049 ownerArray, 8050 index 8051 ) { 8052 if (isDef(vnode.elm) && isDef(ownerArray)) { 8053 // This vnode was used in a previous render! 8054 // now it's used as a new node, overwriting its elm would cause 8055 // potential patch errors down the road when it's used as an insertion 8056 // reference node. Instead, we clone the node on-demand before creating 8057 // associated DOM element for it. 8058 vnode = ownerArray[index] = cloneVNode(vnode); 8059 } 8060 8061 vnode.isRootInsert = !nested; // for transition enter check 8062 if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) { 8063 return 8064 } 8065 8066 var data = vnode.data; 8067 var children = vnode.children; 8068 var tag = vnode.tag; 8069 if (isDef(tag)) { 8070 { 8071 if (data && data.pre) { 8072 creatingElmInVPre++; 8073 } 8074 if (isUnknownElement$$1(vnode, creatingElmInVPre)) { 8075 warn( 8076 'Unknown custom element: <' + tag + '> - did you ' + 8077 'register the component correctly? For recursive components, ' + 8078 'make sure to provide the "name" option.', 8079 vnode.context 8080 ); 8081 } 8082 } 8083 8084 vnode.elm = vnode.ns 8085 ? nodeOps.createElementNS(vnode.ns, tag) 8086 : nodeOps.createElement(tag, vnode); 8087 setScope(vnode); 8088 8089 /* istanbul ignore if */ 8090 { 8091 createChildren(vnode, children, insertedVnodeQueue); 8092 if (isDef(data)) { 8093 invokeCreateHooks(vnode, insertedVnodeQueue); 8094 } 8095 insert(parentElm, vnode.elm, refElm); 8096 } 8097 8098 if (data && data.pre) { 8099 creatingElmInVPre--; 8100 } 8101 } else if (isTrue(vnode.isComment)) { 8102 vnode.elm = nodeOps.createComment(vnode.text); 8103 insert(parentElm, vnode.elm, refElm); 8104 } else { 8105 vnode.elm = nodeOps.createTextNode(vnode.text); 8106 insert(parentElm, vnode.elm, refElm); 8107 } 8108 } 8109 8110 function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 8111 var i = vnode.data; 8112 if (isDef(i)) { 8113 var isReactivated = isDef(vnode.componentInstance) && i.keepAlive; 8114 if (isDef(i = i.hook) && isDef(i = i.init)) { 8115 i(vnode, false /* hydrating */); 8116 } 8117 // after calling the init hook, if the vnode is a child component 8118 // it should've created a child instance and mounted it. the child 8119 // component also has set the placeholder vnode's elm. 8120 // in that case we can just return the element and be done. 8121 if (isDef(vnode.componentInstance)) { 8122 initComponent(vnode, insertedVnodeQueue); 8123 insert(parentElm, vnode.elm, refElm); 8124 if (isTrue(isReactivated)) { 8125 reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); 8126 } 8127 return true 8128 } 8129 } 8130 } 8131 8132 function initComponent (vnode, insertedVnodeQueue) { 8133 if (isDef(vnode.data.pendingInsert)) { 8134 insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); 8135 vnode.data.pendingInsert = null; 8136 } 8137 vnode.elm = vnode.componentInstance.$el; 8138 if (isPatchable(vnode)) { 8139 invokeCreateHooks(vnode, insertedVnodeQueue); 8140 setScope(vnode); 8141 } else { 8142 // empty component root. 8143 // skip all element-related modules except for ref (#3455) 8144 registerRef(vnode); 8145 // make sure to invoke the insert hook 8146 insertedVnodeQueue.push(vnode); 8147 } 8148 } 8149 8150 function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) { 8151 var i; 8152 // hack for #4339: a reactivated component with inner transition 8153 // does not trigger because the inner node's created hooks are not called 8154 // again. It's not ideal to involve module-specific logic in here but 8155 // there doesn't seem to be a better way to do it. 8156 var innerNode = vnode; 8157 while (innerNode.componentInstance) { 8158 innerNode = innerNode.componentInstance._vnode; 8159 if (isDef(i = innerNode.data) && isDef(i = i.transition)) { 8160 for (i = 0; i < cbs.activate.length; ++i) { 8161 cbs.activate[i](emptyNode, innerNode); 8162 } 8163 insertedVnodeQueue.push(innerNode); 8164 break 8165 } 8166 } 8167 // unlike a newly created component, 8168 // a reactivated keep-alive component doesn't insert itself 8169 insert(parentElm, vnode.elm, refElm); 8170 } 8171 8172 function insert (parent, elm, ref$$1) { 8173 if (isDef(parent)) { 8174 if (isDef(ref$$1)) { 8175 if (nodeOps.parentNode(ref$$1) === parent) { 8176 nodeOps.insertBefore(parent, elm, ref$$1); 8177 } 8178 } else { 8179 nodeOps.appendChild(parent, elm); 8180 } 8181 } 8182 } 8183 8184 function createChildren (vnode, children, insertedVnodeQueue) { 8185 if (Array.isArray(children)) { 8186 { 8187 checkDuplicateKeys(children); 8188 } 8189 for (var i = 0; i < children.length; ++i) { 8190 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i); 8191 } 8192 } else if (isPrimitive(vnode.text)) { 8193 nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text))); 8194 } 8195 } 8196 8197 function isPatchable (vnode) { 8198 while (vnode.componentInstance) { 8199 vnode = vnode.componentInstance._vnode; 8200 } 8201 return isDef(vnode.tag) 8202 } 8203 8204 function invokeCreateHooks (vnode, insertedVnodeQueue) { 8205 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 8206 cbs.create[i$1](emptyNode, vnode); 8207 } 8208 i = vnode.data.hook; // Reuse variable 8209 if (isDef(i)) { 8210 if (isDef(i.create)) { i.create(emptyNode, vnode); } 8211 if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); } 8212 } 8213 } 8214 8215 // set scope id attribute for scoped CSS. 8216 // this is implemented as a special case to avoid the overhead 8217 // of going through the normal attribute patching process. 8218 function setScope (vnode) { 8219 var i; 8220 if (isDef(i = vnode.fnScopeId)) { 8221 nodeOps.setStyleScope(vnode.elm, i); 8222 } else { 8223 var ancestor = vnode; 8224 while (ancestor) { 8225 if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) { 8226 nodeOps.setStyleScope(vnode.elm, i); 8227 } 8228 ancestor = ancestor.parent; 8229 } 8230 } 8231 // for slot content they should also get the scopeId from the host instance. 8232 if (isDef(i = activeInstance) && 8233 i !== vnode.context && 8234 i !== vnode.fnContext && 8235 isDef(i = i.$options._scopeId) 8236 ) { 8237 nodeOps.setStyleScope(vnode.elm, i); 8238 } 8239 } 8240 8241 function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { 8242 for (; startIdx <= endIdx; ++startIdx) { 8243 createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx); 8244 } 8245 } 8246 8247 function invokeDestroyHook (vnode) { 8248 var i, j; 8249 var data = vnode.data; 8250 if (isDef(data)) { 8251 if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); } 8252 for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); } 8253 } 8254 if (isDef(i = vnode.children)) { 8255 for (j = 0; j < vnode.children.length; ++j) { 8256 invokeDestroyHook(vnode.children[j]); 8257 } 8258 } 8259 } 8260 8261 function removeVnodes (vnodes, startIdx, endIdx) { 8262 for (; startIdx <= endIdx; ++startIdx) { 8263 var ch = vnodes[startIdx]; 8264 if (isDef(ch)) { 8265 if (isDef(ch.tag)) { 8266 removeAndInvokeRemoveHook(ch); 8267 invokeDestroyHook(ch); 8268 } else { // Text node 8269 removeNode(ch.elm); 8270 } 8271 } 8272 } 8273 } 8274 8275 function removeAndInvokeRemoveHook (vnode, rm) { 8276 if (isDef(rm) || isDef(vnode.data)) { 8277 var i; 8278 var listeners = cbs.remove.length + 1; 8279 if (isDef(rm)) { 8280 // we have a recursively passed down rm callback 8281 // increase the listeners count 8282 rm.listeners += listeners; 8283 } else { 8284 // directly removing 8285 rm = createRmCb(vnode.elm, listeners); 8286 } 8287 // recursively invoke hooks on child component root node 8288 if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) { 8289 removeAndInvokeRemoveHook(i, rm); 8290 } 8291 for (i = 0; i < cbs.remove.length; ++i) { 8292 cbs.remove[i](vnode, rm); 8293 } 8294 if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) { 8295 i(vnode, rm); 8296 } else { 8297 rm(); 8298 } 8299 } else { 8300 removeNode(vnode.elm); 8301 } 8302 } 8303 8304 function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { 8305 var oldStartIdx = 0; 8306 var newStartIdx = 0; 8307 var oldEndIdx = oldCh.length - 1; 8308 var oldStartVnode = oldCh[0]; 8309 var oldEndVnode = oldCh[oldEndIdx]; 8310 var newEndIdx = newCh.length - 1; 8311 var newStartVnode = newCh[0]; 8312 var newEndVnode = newCh[newEndIdx]; 8313 var oldKeyToIdx, idxInOld, vnodeToMove, refElm; 8314 8315 // removeOnly is a special flag used only by <transition-group> 8316 // to ensure removed elements stay in correct relative positions 8317 // during leaving transitions 8318 var canMove = !removeOnly; 8319 8320 { 8321 checkDuplicateKeys(newCh); 8322 } 8323 8324 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { 8325 if (isUndef(oldStartVnode)) { 8326 oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left 8327 } else if (isUndef(oldEndVnode)) { 8328 oldEndVnode = oldCh[--oldEndIdx]; 8329 } else if (sameVnode(oldStartVnode, newStartVnode)) { 8330 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 8331 oldStartVnode = oldCh[++oldStartIdx]; 8332 newStartVnode = newCh[++newStartIdx]; 8333 } else if (sameVnode(oldEndVnode, newEndVnode)) { 8334 patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); 8335 oldEndVnode = oldCh[--oldEndIdx]; 8336 newEndVnode = newCh[--newEndIdx]; 8337 } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right 8338 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); 8339 canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm)); 8340 oldStartVnode = oldCh[++oldStartIdx]; 8341 newEndVnode = newCh[--newEndIdx]; 8342 } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left 8343 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 8344 canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); 8345 oldEndVnode = oldCh[--oldEndIdx]; 8346 newStartVnode = newCh[++newStartIdx]; 8347 } else { 8348 if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); } 8349 idxInOld = isDef(newStartVnode.key) 8350 ? oldKeyToIdx[newStartVnode.key] 8351 : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); 8352 if (isUndef(idxInOld)) { // New element 8353 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); 8354 } else { 8355 vnodeToMove = oldCh[idxInOld]; 8356 if (sameVnode(vnodeToMove, newStartVnode)) { 8357 patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); 8358 oldCh[idxInOld] = undefined; 8359 canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); 8360 } else { 8361 // same key but different element. treat as new element 8362 createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); 8363 } 8364 } 8365 newStartVnode = newCh[++newStartIdx]; 8366 } 8367 } 8368 if (oldStartIdx > oldEndIdx) { 8369 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; 8370 addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); 8371 } else if (newStartIdx > newEndIdx) { 8372 removeVnodes(oldCh, oldStartIdx, oldEndIdx); 8373 } 8374 } 8375 8376 function checkDuplicateKeys (children) { 8377 var seenKeys = {}; 8378 for (var i = 0; i < children.length; i++) { 8379 var vnode = children[i]; 8380 var key = vnode.key; 8381 if (isDef(key)) { 8382 if (seenKeys[key]) { 8383 warn( 8384 ("Duplicate keys detected: '" + key + "'. This may cause an update error."), 8385 vnode.context 8386 ); 8387 } else { 8388 seenKeys[key] = true; 8389 } 8390 } 8391 } 8392 } 8393 8394 function findIdxInOld (node, oldCh, start, end) { 8395 for (var i = start; i < end; i++) { 8396 var c = oldCh[i]; 8397 if (isDef(c) && sameVnode(node, c)) { return i } 8398 } 8399 } 8400 8401 function patchVnode ( 8402 oldVnode, 8403 vnode, 8404 insertedVnodeQueue, 8405 ownerArray, 8406 index, 8407 removeOnly 8408 ) { 8409 if (oldVnode === vnode) { 8410 return 8411 } 8412 8413 if (isDef(vnode.elm) && isDef(ownerArray)) { 8414 // clone reused vnode 8415 vnode = ownerArray[index] = cloneVNode(vnode); 8416 } 8417 8418 var elm = vnode.elm = oldVnode.elm; 8419 8420 if (isTrue(oldVnode.isAsyncPlaceholder)) { 8421 if (isDef(vnode.asyncFactory.resolved)) { 8422 hydrate(oldVnode.elm, vnode, insertedVnodeQueue); 8423 } else { 8424 vnode.isAsyncPlaceholder = true; 8425 } 8426 return 8427 } 8428 8429 // reuse element for static trees. 8430 // note we only do this if the vnode is cloned - 8431 // if the new node is not cloned it means the render functions have been 8432 // reset by the hot-reload-api and we need to do a proper re-render. 8433 if (isTrue(vnode.isStatic) && 8434 isTrue(oldVnode.isStatic) && 8435 vnode.key === oldVnode.key && 8436 (isTrue(vnode.isCloned) || isTrue(vnode.isOnce)) 8437 ) { 8438 vnode.componentInstance = oldVnode.componentInstance; 8439 return 8440 } 8441 8442 var i; 8443 var data = vnode.data; 8444 if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) { 8445 i(oldVnode, vnode); 8446 } 8447 8448 var oldCh = oldVnode.children; 8449 var ch = vnode.children; 8450 if (isDef(data) && isPatchable(vnode)) { 8451 for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); } 8452 if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); } 8453 } 8454 if (isUndef(vnode.text)) { 8455 if (isDef(oldCh) && isDef(ch)) { 8456 if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); } 8457 } else if (isDef(ch)) { 8458 { 8459 checkDuplicateKeys(ch); 8460 } 8461 if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); } 8462 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); 8463 } else if (isDef(oldCh)) { 8464 removeVnodes(oldCh, 0, oldCh.length - 1); 8465 } else if (isDef(oldVnode.text)) { 8466 nodeOps.setTextContent(elm, ''); 8467 } 8468 } else if (oldVnode.text !== vnode.text) { 8469 nodeOps.setTextContent(elm, vnode.text); 8470 } 8471 if (isDef(data)) { 8472 if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); } 8473 } 8474 } 8475 8476 function invokeInsertHook (vnode, queue, initial) { 8477 // delay insert hooks for component root nodes, invoke them after the 8478 // element is really inserted 8479 if (isTrue(initial) && isDef(vnode.parent)) { 8480 vnode.parent.data.pendingInsert = queue; 8481 } else { 8482 for (var i = 0; i < queue.length; ++i) { 8483 queue[i].data.hook.insert(queue[i]); 8484 } 8485 } 8486 } 8487 8488 var hydrationBailed = false; 8489 // list of modules that can skip create hook during hydration because they 8490 // are already rendered on the client or has no need for initialization 8491 // Note: style is excluded because it relies on initial clone for future 8492 // deep updates (#7063). 8493 var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key'); 8494 8495 // Note: this is a browser-only function so we can assume elms are DOM nodes. 8496 function hydrate (elm, vnode, insertedVnodeQueue, inVPre) { 8497 var i; 8498 var tag = vnode.tag; 8499 var data = vnode.data; 8500 var children = vnode.children; 8501 inVPre = inVPre || (data && data.pre); 8502 vnode.elm = elm; 8503 8504 if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { 8505 vnode.isAsyncPlaceholder = true; 8506 return true 8507 } 8508 // assert node match 8509 { 8510 if (!assertNodeMatch(elm, vnode, inVPre)) { 8511 return false 8512 } 8513 } 8514 if (isDef(data)) { 8515 if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); } 8516 if (isDef(i = vnode.componentInstance)) { 8517 // child component. it should have hydrated its own tree. 8518 initComponent(vnode, insertedVnodeQueue); 8519 return true 8520 } 8521 } 8522 if (isDef(tag)) { 8523 if (isDef(children)) { 8524 // empty element, allow client to pick up and populate children 8525 if (!elm.hasChildNodes()) { 8526 createChildren(vnode, children, insertedVnodeQueue); 8527 } else { 8528 // v-html and domProps: innerHTML 8529 if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) { 8530 if (i !== elm.innerHTML) { 8531 /* istanbul ignore if */ 8532 if (typeof console !== 'undefined' && 8533 !hydrationBailed 8534 ) { 8535 hydrationBailed = true; 8536 console.warn('Parent: ', elm); 8537 console.warn('server innerHTML: ', i); 8538 console.warn('client innerHTML: ', elm.innerHTML); 8539 } 8540 return false 8541 } 8542 } else { 8543 // iterate and compare children lists 8544 var childrenMatch = true; 8545 var childNode = elm.firstChild; 8546 for (var i$1 = 0; i$1 < children.length; i$1++) { 8547 if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) { 8548 childrenMatch = false; 8549 break 8550 } 8551 childNode = childNode.nextSibling; 8552 } 8553 // if childNode is not null, it means the actual childNodes list is 8554 // longer than the virtual children list. 8555 if (!childrenMatch || childNode) { 8556 /* istanbul ignore if */ 8557 if (typeof console !== 'undefined' && 8558 !hydrationBailed 8559 ) { 8560 hydrationBailed = true; 8561 console.warn('Parent: ', elm); 8562 console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children); 8563 } 8564 return false 8565 } 8566 } 8567 } 8568 } 8569 if (isDef(data)) { 8570 var fullInvoke = false; 8571 for (var key in data) { 8572 if (!isRenderedModule(key)) { 8573 fullInvoke = true; 8574 invokeCreateHooks(vnode, insertedVnodeQueue); 8575 break 8576 } 8577 } 8578 if (!fullInvoke && data['class']) { 8579 // ensure collecting deps for deep class bindings for future updates 8580 traverse(data['class']); 8581 } 8582 } 8583 } else if (elm.data !== vnode.text) { 8584 elm.data = vnode.text; 8585 } 8586 return true 8587 } 8588 8589 function assertNodeMatch (node, vnode, inVPre) { 8590 if (isDef(vnode.tag)) { 8591 return vnode.tag.indexOf('vue-component') === 0 || ( 8592 !isUnknownElement$$1(vnode, inVPre) && 8593 vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()) 8594 ) 8595 } else { 8596 return node.nodeType === (vnode.isComment ? 8 : 3) 8597 } 8598 } 8599 8600 return function patch (oldVnode, vnode, hydrating, removeOnly) { 8601 if (isUndef(vnode)) { 8602 if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); } 8603 return 8604 } 8605 8606 var isInitialPatch = false; 8607 var insertedVnodeQueue = []; 8608 8609 if (isUndef(oldVnode)) { 8610 // empty mount (likely as component), create new root element 8611 isInitialPatch = true; 8612 createElm(vnode, insertedVnodeQueue); 8613 } else { 8614 var isRealElement = isDef(oldVnode.nodeType); 8615 if (!isRealElement && sameVnode(oldVnode, vnode)) { 8616 // patch existing root node 8617 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly); 8618 } else { 8619 if (isRealElement) { 8620 // mounting to a real element 8621 // check if this is server-rendered content and if we can perform 8622 // a successful hydration. 8623 if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { 8624 oldVnode.removeAttribute(SSR_ATTR); 8625 hydrating = true; 8626 } 8627 if (isTrue(hydrating)) { 8628 if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { 8629 invokeInsertHook(vnode, insertedVnodeQueue, true); 8630 return oldVnode 8631 } else { 8632 warn( 8633 'The client-side rendered virtual DOM tree is not matching ' + 8634 'server-rendered content. This is likely caused by incorrect ' + 8635 'HTML markup, for example nesting block-level elements inside ' + 8636 '<p>, or missing <tbody>. Bailing hydration and performing ' + 8637 'full client-side render.' 8638 ); 8639 } 8640 } 8641 // either not server-rendered, or hydration failed. 8642 // create an empty node and replace it 8643 oldVnode = emptyNodeAt(oldVnode); 8644 } 8645 8646 // replacing existing element 8647 var oldElm = oldVnode.elm; 8648 var parentElm = nodeOps.parentNode(oldElm); 8649 8650 // create new node 8651 createElm( 8652 vnode, 8653 insertedVnodeQueue, 8654 // extremely rare edge case: do not insert if old element is in a 8655 // leaving transition. Only happens when combining transition + 8656 // keep-alive + HOCs. (#4590) 8657 oldElm._leaveCb ? null : parentElm, 8658 nodeOps.nextSibling(oldElm) 8659 ); 8660 8661 // update parent placeholder node element, recursively 8662 if (isDef(vnode.parent)) { 8663 var ancestor = vnode.parent; 8664 var patchable = isPatchable(vnode); 8665 while (ancestor) { 8666 for (var i = 0; i < cbs.destroy.length; ++i) { 8667 cbs.destroy[i](ancestor); 8668 } 8669 ancestor.elm = vnode.elm; 8670 if (patchable) { 8671 for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { 8672 cbs.create[i$1](emptyNode, ancestor); 8673 } 8674 // #6513 8675 // invoke insert hooks that may have been merged by create hooks. 8676 // e.g. for directives that uses the "inserted" hook. 8677 var insert = ancestor.data.hook.insert; 8678 if (insert.merged) { 8679 // start at index 1 to avoid re-invoking component mounted hook 8680 for (var i$2 = 1; i$2 < insert.fns.length; i$2++) { 8681 insert.fns[i$2](); 8682 } 8683 } 8684 } else { 8685 registerRef(ancestor); 8686 } 8687 ancestor = ancestor.parent; 8688 } 8689 } 8690 8691 // destroy old node 8692 if (isDef(parentElm)) { 8693 removeVnodes([oldVnode], 0, 0); 8694 } else if (isDef(oldVnode.tag)) { 8695 invokeDestroyHook(oldVnode); 8696 } 8697 } 8698 } 8699 8700 invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); 8701 return vnode.elm 8702 } 8703} 8704 8705/* */ 8706 8707var directives = { 8708 create: updateDirectives, 8709 update: updateDirectives, 8710 destroy: function unbindDirectives (vnode) { 8711 updateDirectives(vnode, emptyNode); 8712 } 8713}; 8714 8715function updateDirectives (oldVnode, vnode) { 8716 if (oldVnode.data.directives || vnode.data.directives) { 8717 _update(oldVnode, vnode); 8718 } 8719} 8720 8721function _update (oldVnode, vnode) { 8722 var isCreate = oldVnode === emptyNode; 8723 var isDestroy = vnode === emptyNode; 8724 var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); 8725 var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); 8726 8727 var dirsWithInsert = []; 8728 var dirsWithPostpatch = []; 8729 8730 var key, oldDir, dir; 8731 for (key in newDirs) { 8732 oldDir = oldDirs[key]; 8733 dir = newDirs[key]; 8734 if (!oldDir) { 8735 // new directive, bind 8736 callHook$1(dir, 'bind', vnode, oldVnode); 8737 if (dir.def && dir.def.inserted) { 8738 dirsWithInsert.push(dir); 8739 } 8740 } else { 8741 // existing directive, update 8742 dir.oldValue = oldDir.value; 8743 dir.oldArg = oldDir.arg; 8744 callHook$1(dir, 'update', vnode, oldVnode); 8745 if (dir.def && dir.def.componentUpdated) { 8746 dirsWithPostpatch.push(dir); 8747 } 8748 } 8749 } 8750 8751 if (dirsWithInsert.length) { 8752 var callInsert = function () { 8753 for (var i = 0; i < dirsWithInsert.length; i++) { 8754 callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode); 8755 } 8756 }; 8757 if (isCreate) { 8758 mergeVNodeHook(vnode, 'insert', callInsert); 8759 } else { 8760 callInsert(); 8761 } 8762 } 8763 8764 if (dirsWithPostpatch.length) { 8765 mergeVNodeHook(vnode, 'postpatch', function () { 8766 for (var i = 0; i < dirsWithPostpatch.length; i++) { 8767 callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode); 8768 } 8769 }); 8770 } 8771 8772 if (!isCreate) { 8773 for (key in oldDirs) { 8774 if (!newDirs[key]) { 8775 // no longer present, unbind 8776 callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy); 8777 } 8778 } 8779 } 8780} 8781 8782var emptyModifiers = Object.create(null); 8783 8784function normalizeDirectives$1 ( 8785 dirs, 8786 vm 8787) { 8788 var res = Object.create(null); 8789 if (!dirs) { 8790 // $flow-disable-line 8791 return res 8792 } 8793 var i, dir; 8794 for (i = 0; i < dirs.length; i++) { 8795 dir = dirs[i]; 8796 if (!dir.modifiers) { 8797 // $flow-disable-line 8798 dir.modifiers = emptyModifiers; 8799 } 8800 res[getRawDirName(dir)] = dir; 8801 dir.def = resolveAsset(vm.$options, 'directives', dir.name, true); 8802 } 8803 // $flow-disable-line 8804 return res 8805} 8806 8807function getRawDirName (dir) { 8808 return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))) 8809} 8810 8811function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) { 8812 var fn = dir.def && dir.def[hook]; 8813 if (fn) { 8814 try { 8815 fn(vnode.elm, dir, vnode, oldVnode, isDestroy); 8816 } catch (e) { 8817 handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook")); 8818 } 8819 } 8820} 8821 8822var baseModules = [ 8823 ref, 8824 directives 8825]; 8826 8827/* */ 8828 8829function updateAttrs (oldVnode, vnode) { 8830 var opts = vnode.componentOptions; 8831 if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { 8832 return 8833 } 8834 if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { 8835 return 8836 } 8837 var key, cur, old; 8838 var elm = vnode.elm; 8839 var oldAttrs = oldVnode.data.attrs || {}; 8840 var attrs = vnode.data.attrs || {}; 8841 // clone observed objects, as the user probably wants to mutate it 8842 if (isDef(attrs.__ob__)) { 8843 attrs = vnode.data.attrs = extend({}, attrs); 8844 } 8845 8846 for (key in attrs) { 8847 cur = attrs[key]; 8848 old = oldAttrs[key]; 8849 if (old !== cur) { 8850 setAttr(elm, key, cur, vnode.data.pre); 8851 } 8852 } 8853 // #4391: in IE9, setting type can reset value for input[type=radio] 8854 // #6666: IE/Edge forces progress value down to 1 before setting a max 8855 /* istanbul ignore if */ 8856 if ((isIE || isEdge) && attrs.value !== oldAttrs.value) { 8857 setAttr(elm, 'value', attrs.value); 8858 } 8859 for (key in oldAttrs) { 8860 if (isUndef(attrs[key])) { 8861 if (isXlink(key)) { 8862 elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); 8863 } else if (!isEnumeratedAttr(key)) { 8864 elm.removeAttribute(key); 8865 } 8866 } 8867 } 8868} 8869 8870function setAttr (el, key, value, isInPre) { 8871 if (isInPre || el.tagName.indexOf('-') > -1) { 8872 baseSetAttr(el, key, value); 8873 } else if (isBooleanAttr(key)) { 8874 // set attribute for blank value 8875 // e.g. <option disabled>Select one</option> 8876 if (isFalsyAttrValue(value)) { 8877 el.removeAttribute(key); 8878 } else { 8879 // technically allowfullscreen is a boolean attribute for <iframe>, 8880 // but Flash expects a value of "true" when used on <embed> tag 8881 value = key === 'allowfullscreen' && el.tagName === 'EMBED' 8882 ? 'true' 8883 : key; 8884 el.setAttribute(key, value); 8885 } 8886 } else if (isEnumeratedAttr(key)) { 8887 el.setAttribute(key, convertEnumeratedValue(key, value)); 8888 } else if (isXlink(key)) { 8889 if (isFalsyAttrValue(value)) { 8890 el.removeAttributeNS(xlinkNS, getXlinkProp(key)); 8891 } else { 8892 el.setAttributeNS(xlinkNS, key, value); 8893 } 8894 } else { 8895 baseSetAttr(el, key, value); 8896 } 8897} 8898 8899function baseSetAttr (el, key, value) { 8900 if (isFalsyAttrValue(value)) { 8901 el.removeAttribute(key); 8902 } else { 8903 // #7138: IE10 & 11 fires input event when setting placeholder on 8904 // <textarea>... block the first input event and remove the blocker 8905 // immediately. 8906 /* istanbul ignore if */ 8907 if ( 8908 isIE && !isIE9 && 8909 el.tagName === 'TEXTAREA' && 8910 key === 'placeholder' && value !== '' && !el.__ieph 8911 ) { 8912 var blocker = function (e) { 8913 e.stopImmediatePropagation(); 8914 el.removeEventListener('input', blocker); 8915 }; 8916 el.addEventListener('input', blocker); 8917 // $flow-disable-line 8918 el.__ieph = true; /* IE placeholder patched */ 8919 } 8920 el.setAttribute(key, value); 8921 } 8922} 8923 8924var attrs = { 8925 create: updateAttrs, 8926 update: updateAttrs 8927}; 8928 8929/* */ 8930 8931function updateClass (oldVnode, vnode) { 8932 var el = vnode.elm; 8933 var data = vnode.data; 8934 var oldData = oldVnode.data; 8935 if ( 8936 isUndef(data.staticClass) && 8937 isUndef(data.class) && ( 8938 isUndef(oldData) || ( 8939 isUndef(oldData.staticClass) && 8940 isUndef(oldData.class) 8941 ) 8942 ) 8943 ) { 8944 return 8945 } 8946 8947 var cls = genClassForVnode(vnode); 8948 8949 // handle transition classes 8950 var transitionClass = el._transitionClasses; 8951 if (isDef(transitionClass)) { 8952 cls = concat(cls, stringifyClass(transitionClass)); 8953 } 8954 8955 // set the class 8956 if (cls !== el._prevClass) { 8957 el.setAttribute('class', cls); 8958 el._prevClass = cls; 8959 } 8960} 8961 8962var klass = { 8963 create: updateClass, 8964 update: updateClass 8965}; 8966 8967/* */ 8968 8969var validDivisionCharRE = /[\w).+\-_$\]]/; 8970 8971function parseFilters (exp) { 8972 var inSingle = false; 8973 var inDouble = false; 8974 var inTemplateString = false; 8975 var inRegex = false; 8976 var curly = 0; 8977 var square = 0; 8978 var paren = 0; 8979 var lastFilterIndex = 0; 8980 var c, prev, i, expression, filters; 8981 8982 for (i = 0; i < exp.length; i++) { 8983 prev = c; 8984 c = exp.charCodeAt(i); 8985 if (inSingle) { 8986 if (c === 0x27 && prev !== 0x5C) { inSingle = false; } 8987 } else if (inDouble) { 8988 if (c === 0x22 && prev !== 0x5C) { inDouble = false; } 8989 } else if (inTemplateString) { 8990 if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; } 8991 } else if (inRegex) { 8992 if (c === 0x2f && prev !== 0x5C) { inRegex = false; } 8993 } else if ( 8994 c === 0x7C && // pipe 8995 exp.charCodeAt(i + 1) !== 0x7C && 8996 exp.charCodeAt(i - 1) !== 0x7C && 8997 !curly && !square && !paren 8998 ) { 8999 if (expression === undefined) { 9000 // first filter, end of expression 9001 lastFilterIndex = i + 1; 9002 expression = exp.slice(0, i).trim(); 9003 } else { 9004 pushFilter(); 9005 } 9006 } else { 9007 switch (c) { 9008 case 0x22: inDouble = true; break // " 9009 case 0x27: inSingle = true; break // ' 9010 case 0x60: inTemplateString = true; break // ` 9011 case 0x28: paren++; break // ( 9012 case 0x29: paren--; break // ) 9013 case 0x5B: square++; break // [ 9014 case 0x5D: square--; break // ] 9015 case 0x7B: curly++; break // { 9016 case 0x7D: curly--; break // } 9017 } 9018 if (c === 0x2f) { // / 9019 var j = i - 1; 9020 var p = (void 0); 9021 // find first non-whitespace prev char 9022 for (; j >= 0; j--) { 9023 p = exp.charAt(j); 9024 if (p !== ' ') { break } 9025 } 9026 if (!p || !validDivisionCharRE.test(p)) { 9027 inRegex = true; 9028 } 9029 } 9030 } 9031 } 9032 9033 if (expression === undefined) { 9034 expression = exp.slice(0, i).trim(); 9035 } else if (lastFilterIndex !== 0) { 9036 pushFilter(); 9037 } 9038 9039 function pushFilter () { 9040 (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); 9041 lastFilterIndex = i + 1; 9042 } 9043 9044 if (filters) { 9045 for (i = 0; i < filters.length; i++) { 9046 expression = wrapFilter(expression, filters[i]); 9047 } 9048 } 9049 9050 return expression 9051} 9052 9053function wrapFilter (exp, filter) { 9054 var i = filter.indexOf('('); 9055 if (i < 0) { 9056 // _f: resolveFilter 9057 return ("_f(\"" + filter + "\")(" + exp + ")") 9058 } else { 9059 var name = filter.slice(0, i); 9060 var args = filter.slice(i + 1); 9061 return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args)) 9062 } 9063} 9064 9065/* */ 9066 9067 9068 9069/* eslint-disable no-unused-vars */ 9070function baseWarn (msg, range) { 9071 console.error(("[Vue compiler]: " + msg)); 9072} 9073/* eslint-enable no-unused-vars */ 9074 9075function pluckModuleFunction ( 9076 modules, 9077 key 9078) { 9079 return modules 9080 ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) 9081 : [] 9082} 9083 9084function addProp (el, name, value, range, dynamic) { 9085 (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)); 9086 el.plain = false; 9087} 9088 9089function addAttr (el, name, value, range, dynamic) { 9090 var attrs = dynamic 9091 ? (el.dynamicAttrs || (el.dynamicAttrs = [])) 9092 : (el.attrs || (el.attrs = [])); 9093 attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)); 9094 el.plain = false; 9095} 9096 9097// add a raw attr (use this in preTransforms) 9098function addRawAttr (el, name, value, range) { 9099 el.attrsMap[name] = value; 9100 el.attrsList.push(rangeSetItem({ name: name, value: value }, range)); 9101} 9102 9103function addDirective ( 9104 el, 9105 name, 9106 rawName, 9107 value, 9108 arg, 9109 isDynamicArg, 9110 modifiers, 9111 range 9112) { 9113 (el.directives || (el.directives = [])).push(rangeSetItem({ 9114 name: name, 9115 rawName: rawName, 9116 value: value, 9117 arg: arg, 9118 isDynamicArg: isDynamicArg, 9119 modifiers: modifiers 9120 }, range)); 9121 el.plain = false; 9122} 9123 9124function prependModifierMarker (symbol, name, dynamic) { 9125 return dynamic 9126 ? ("_p(" + name + ",\"" + symbol + "\")") 9127 : symbol + name // mark the event as captured 9128} 9129 9130function addHandler ( 9131 el, 9132 name, 9133 value, 9134 modifiers, 9135 important, 9136 warn, 9137 range, 9138 dynamic 9139) { 9140 modifiers = modifiers || emptyObject; 9141 // warn prevent and passive modifier 9142 /* istanbul ignore if */ 9143 if ( 9144 warn && 9145 modifiers.prevent && modifiers.passive 9146 ) { 9147 warn( 9148 'passive and prevent can\'t be used together. ' + 9149 'Passive handler can\'t prevent default event.', 9150 range 9151 ); 9152 } 9153 9154 // normalize click.right and click.middle since they don't actually fire 9155 // this is technically browser-specific, but at least for now browsers are 9156 // the only target envs that have right/middle clicks. 9157 if (modifiers.right) { 9158 if (dynamic) { 9159 name = "(" + name + ")==='click'?'contextmenu':(" + name + ")"; 9160 } else if (name === 'click') { 9161 name = 'contextmenu'; 9162 delete modifiers.right; 9163 } 9164 } else if (modifiers.middle) { 9165 if (dynamic) { 9166 name = "(" + name + ")==='click'?'mouseup':(" + name + ")"; 9167 } else if (name === 'click') { 9168 name = 'mouseup'; 9169 } 9170 } 9171 9172 // check capture modifier 9173 if (modifiers.capture) { 9174 delete modifiers.capture; 9175 name = prependModifierMarker('!', name, dynamic); 9176 } 9177 if (modifiers.once) { 9178 delete modifiers.once; 9179 name = prependModifierMarker('~', name, dynamic); 9180 } 9181 /* istanbul ignore if */ 9182 if (modifiers.passive) { 9183 delete modifiers.passive; 9184 name = prependModifierMarker('&', name, dynamic); 9185 } 9186 9187 var events; 9188 if (modifiers.native) { 9189 delete modifiers.native; 9190 events = el.nativeEvents || (el.nativeEvents = {}); 9191 } else { 9192 events = el.events || (el.events = {}); 9193 } 9194 9195 var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range); 9196 if (modifiers !== emptyObject) { 9197 newHandler.modifiers = modifiers; 9198 } 9199 9200 var handlers = events[name]; 9201 /* istanbul ignore if */ 9202 if (Array.isArray(handlers)) { 9203 important ? handlers.unshift(newHandler) : handlers.push(newHandler); 9204 } else if (handlers) { 9205 events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; 9206 } else { 9207 events[name] = newHandler; 9208 } 9209 9210 el.plain = false; 9211} 9212 9213function getRawBindingAttr ( 9214 el, 9215 name 9216) { 9217 return el.rawAttrsMap[':' + name] || 9218 el.rawAttrsMap['v-bind:' + name] || 9219 el.rawAttrsMap[name] 9220} 9221 9222function getBindingAttr ( 9223 el, 9224 name, 9225 getStatic 9226) { 9227 var dynamicValue = 9228 getAndRemoveAttr(el, ':' + name) || 9229 getAndRemoveAttr(el, 'v-bind:' + name); 9230 if (dynamicValue != null) { 9231 return parseFilters(dynamicValue) 9232 } else if (getStatic !== false) { 9233 var staticValue = getAndRemoveAttr(el, name); 9234 if (staticValue != null) { 9235 return JSON.stringify(staticValue) 9236 } 9237 } 9238} 9239 9240// note: this only removes the attr from the Array (attrsList) so that it 9241// doesn't get processed by processAttrs. 9242// By default it does NOT remove it from the map (attrsMap) because the map is 9243// needed during codegen. 9244function getAndRemoveAttr ( 9245 el, 9246 name, 9247 removeFromMap 9248) { 9249 var val; 9250 if ((val = el.attrsMap[name]) != null) { 9251 var list = el.attrsList; 9252 for (var i = 0, l = list.length; i < l; i++) { 9253 if (list[i].name === name) { 9254 list.splice(i, 1); 9255 break 9256 } 9257 } 9258 } 9259 if (removeFromMap) { 9260 delete el.attrsMap[name]; 9261 } 9262 return val 9263} 9264 9265function getAndRemoveAttrByRegex ( 9266 el, 9267 name 9268) { 9269 var list = el.attrsList; 9270 for (var i = 0, l = list.length; i < l; i++) { 9271 var attr = list[i]; 9272 if (name.test(attr.name)) { 9273 list.splice(i, 1); 9274 return attr 9275 } 9276 } 9277} 9278 9279function rangeSetItem ( 9280 item, 9281 range 9282) { 9283 if (range) { 9284 if (range.start != null) { 9285 item.start = range.start; 9286 } 9287 if (range.end != null) { 9288 item.end = range.end; 9289 } 9290 } 9291 return item 9292} 9293 9294/* */ 9295 9296/** 9297 * Cross-platform code generation for component v-model 9298 */ 9299function genComponentModel ( 9300 el, 9301 value, 9302 modifiers 9303) { 9304 var ref = modifiers || {}; 9305 var number = ref.number; 9306 var trim = ref.trim; 9307 9308 var baseValueExpression = '$$v'; 9309 var valueExpression = baseValueExpression; 9310 if (trim) { 9311 valueExpression = 9312 "(typeof " + baseValueExpression + " === 'string'" + 9313 "? " + baseValueExpression + ".trim()" + 9314 ": " + baseValueExpression + ")"; 9315 } 9316 if (number) { 9317 valueExpression = "_n(" + valueExpression + ")"; 9318 } 9319 var assignment = genAssignmentCode(value, valueExpression); 9320 9321 el.model = { 9322 value: ("(" + value + ")"), 9323 expression: JSON.stringify(value), 9324 callback: ("function (" + baseValueExpression + ") {" + assignment + "}") 9325 }; 9326} 9327 9328/** 9329 * Cross-platform codegen helper for generating v-model value assignment code. 9330 */ 9331function genAssignmentCode ( 9332 value, 9333 assignment 9334) { 9335 var res = parseModel(value); 9336 if (res.key === null) { 9337 return (value + "=" + assignment) 9338 } else { 9339 return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")") 9340 } 9341} 9342 9343/** 9344 * Parse a v-model expression into a base path and a final key segment. 9345 * Handles both dot-path and possible square brackets. 9346 * 9347 * Possible cases: 9348 * 9349 * - test 9350 * - test[key] 9351 * - test[test1[key]] 9352 * - test["a"][key] 9353 * - xxx.test[a[a].test1[key]] 9354 * - test.xxx.a["asa"][test1[key]] 9355 * 9356 */ 9357 9358var len, str, chr, index$1, expressionPos, expressionEndPos; 9359 9360 9361 9362function parseModel (val) { 9363 // Fix https://github.com/vuejs/vue/pull/7730 9364 // allow v-model="obj.val " (trailing whitespace) 9365 val = val.trim(); 9366 len = val.length; 9367 9368 if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) { 9369 index$1 = val.lastIndexOf('.'); 9370 if (index$1 > -1) { 9371 return { 9372 exp: val.slice(0, index$1), 9373 key: '"' + val.slice(index$1 + 1) + '"' 9374 } 9375 } else { 9376 return { 9377 exp: val, 9378 key: null 9379 } 9380 } 9381 } 9382 9383 str = val; 9384 index$1 = expressionPos = expressionEndPos = 0; 9385 9386 while (!eof()) { 9387 chr = next(); 9388 /* istanbul ignore if */ 9389 if (isStringStart(chr)) { 9390 parseString(chr); 9391 } else if (chr === 0x5B) { 9392 parseBracket(chr); 9393 } 9394 } 9395 9396 return { 9397 exp: val.slice(0, expressionPos), 9398 key: val.slice(expressionPos + 1, expressionEndPos) 9399 } 9400} 9401 9402function next () { 9403 return str.charCodeAt(++index$1) 9404} 9405 9406function eof () { 9407 return index$1 >= len 9408} 9409 9410function isStringStart (chr) { 9411 return chr === 0x22 || chr === 0x27 9412} 9413 9414function parseBracket (chr) { 9415 var inBracket = 1; 9416 expressionPos = index$1; 9417 while (!eof()) { 9418 chr = next(); 9419 if (isStringStart(chr)) { 9420 parseString(chr); 9421 continue 9422 } 9423 if (chr === 0x5B) { inBracket++; } 9424 if (chr === 0x5D) { inBracket--; } 9425 if (inBracket === 0) { 9426 expressionEndPos = index$1; 9427 break 9428 } 9429 } 9430} 9431 9432function parseString (chr) { 9433 var stringQuote = chr; 9434 while (!eof()) { 9435 chr = next(); 9436 if (chr === stringQuote) { 9437 break 9438 } 9439 } 9440} 9441 9442/* */ 9443 9444var warn$1; 9445 9446// in some cases, the event used has to be determined at runtime 9447// so we used some reserved tokens during compile. 9448var RANGE_TOKEN = '__r'; 9449var CHECKBOX_RADIO_TOKEN = '__c'; 9450 9451function model ( 9452 el, 9453 dir, 9454 _warn 9455) { 9456 warn$1 = _warn; 9457 var value = dir.value; 9458 var modifiers = dir.modifiers; 9459 var tag = el.tag; 9460 var type = el.attrsMap.type; 9461 9462 { 9463 // inputs with type="file" are read only and setting the input's 9464 // value will throw an error. 9465 if (tag === 'input' && type === 'file') { 9466 warn$1( 9467 "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" + 9468 "File inputs are read only. Use a v-on:change listener instead.", 9469 el.rawAttrsMap['v-model'] 9470 ); 9471 } 9472 } 9473 9474 if (el.component) { 9475 genComponentModel(el, value, modifiers); 9476 // component v-model doesn't need extra runtime 9477 return false 9478 } else if (tag === 'select') { 9479 genSelect(el, value, modifiers); 9480 } else if (tag === 'input' && type === 'checkbox') { 9481 genCheckboxModel(el, value, modifiers); 9482 } else if (tag === 'input' && type === 'radio') { 9483 genRadioModel(el, value, modifiers); 9484 } else if (tag === 'input' || tag === 'textarea') { 9485 genDefaultModel(el, value, modifiers); 9486 } else if (!config.isReservedTag(tag)) { 9487 genComponentModel(el, value, modifiers); 9488 // component v-model doesn't need extra runtime 9489 return false 9490 } else { 9491 warn$1( 9492 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 9493 "v-model is not supported on this element type. " + 9494 'If you are working with contenteditable, it\'s recommended to ' + 9495 'wrap a library dedicated for that purpose inside a custom component.', 9496 el.rawAttrsMap['v-model'] 9497 ); 9498 } 9499 9500 // ensure runtime directive metadata 9501 return true 9502} 9503 9504function genCheckboxModel ( 9505 el, 9506 value, 9507 modifiers 9508) { 9509 var number = modifiers && modifiers.number; 9510 var valueBinding = getBindingAttr(el, 'value') || 'null'; 9511 var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'; 9512 var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'; 9513 addProp(el, 'checked', 9514 "Array.isArray(" + value + ")" + 9515 "?_i(" + value + "," + valueBinding + ")>-1" + ( 9516 trueValueBinding === 'true' 9517 ? (":(" + value + ")") 9518 : (":_q(" + value + "," + trueValueBinding + ")") 9519 ) 9520 ); 9521 addHandler(el, 'change', 9522 "var $$a=" + value + "," + 9523 '$$el=$event.target,' + 9524 "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" + 9525 'if(Array.isArray($$a)){' + 9526 "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," + 9527 '$$i=_i($$a,$$v);' + 9528 "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" + 9529 "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" + 9530 "}else{" + (genAssignmentCode(value, '$$c')) + "}", 9531 null, true 9532 ); 9533} 9534 9535function genRadioModel ( 9536 el, 9537 value, 9538 modifiers 9539) { 9540 var number = modifiers && modifiers.number; 9541 var valueBinding = getBindingAttr(el, 'value') || 'null'; 9542 valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding; 9543 addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")")); 9544 addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); 9545} 9546 9547function genSelect ( 9548 el, 9549 value, 9550 modifiers 9551) { 9552 var number = modifiers && modifiers.number; 9553 var selectedVal = "Array.prototype.filter" + 9554 ".call($event.target.options,function(o){return o.selected})" + 9555 ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" + 9556 "return " + (number ? '_n(val)' : 'val') + "})"; 9557 9558 var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; 9559 var code = "var $$selectedVal = " + selectedVal + ";"; 9560 code = code + " " + (genAssignmentCode(value, assignment)); 9561 addHandler(el, 'change', code, null, true); 9562} 9563 9564function genDefaultModel ( 9565 el, 9566 value, 9567 modifiers 9568) { 9569 var type = el.attrsMap.type; 9570 9571 // warn if v-bind:value conflicts with v-model 9572 // except for inputs with v-bind:type 9573 { 9574 var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']; 9575 var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']; 9576 if (value$1 && !typeBinding) { 9577 var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'; 9578 warn$1( 9579 binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " + 9580 'because the latter already expands to a value binding internally', 9581 el.rawAttrsMap[binding] 9582 ); 9583 } 9584 } 9585 9586 var ref = modifiers || {}; 9587 var lazy = ref.lazy; 9588 var number = ref.number; 9589 var trim = ref.trim; 9590 var needCompositionGuard = !lazy && type !== 'range'; 9591 var event = lazy 9592 ? 'change' 9593 : type === 'range' 9594 ? RANGE_TOKEN 9595 : 'input'; 9596 9597 var valueExpression = '$event.target.value'; 9598 if (trim) { 9599 valueExpression = "$event.target.value.trim()"; 9600 } 9601 if (number) { 9602 valueExpression = "_n(" + valueExpression + ")"; 9603 } 9604 9605 var code = genAssignmentCode(value, valueExpression); 9606 if (needCompositionGuard) { 9607 code = "if($event.target.composing)return;" + code; 9608 } 9609 9610 addProp(el, 'value', ("(" + value + ")")); 9611 addHandler(el, event, code, null, true); 9612 if (trim || number) { 9613 addHandler(el, 'blur', '$forceUpdate()'); 9614 } 9615} 9616 9617/* */ 9618 9619// normalize v-model event tokens that can only be determined at runtime. 9620// it's important to place the event as the first in the array because 9621// the whole point is ensuring the v-model callback gets called before 9622// user-attached handlers. 9623function normalizeEvents (on) { 9624 /* istanbul ignore if */ 9625 if (isDef(on[RANGE_TOKEN])) { 9626 // IE input[type=range] only supports `change` event 9627 var event = isIE ? 'change' : 'input'; 9628 on[event] = [].concat(on[RANGE_TOKEN], on[event] || []); 9629 delete on[RANGE_TOKEN]; 9630 } 9631 // This was originally intended to fix #4521 but no longer necessary 9632 // after 2.5. Keeping it for backwards compat with generated code from < 2.4 9633 /* istanbul ignore if */ 9634 if (isDef(on[CHECKBOX_RADIO_TOKEN])) { 9635 on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []); 9636 delete on[CHECKBOX_RADIO_TOKEN]; 9637 } 9638} 9639 9640var target$1; 9641 9642function createOnceHandler$1 (event, handler, capture) { 9643 var _target = target$1; // save current target element in closure 9644 return function onceHandler () { 9645 var res = handler.apply(null, arguments); 9646 if (res !== null) { 9647 remove$2(event, onceHandler, capture, _target); 9648 } 9649 } 9650} 9651 9652// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp 9653// implementation and does not fire microtasks in between event propagation, so 9654// safe to exclude. 9655var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53); 9656 9657function add$1 ( 9658 name, 9659 handler, 9660 capture, 9661 passive 9662) { 9663 // async edge case #6566: inner click event triggers patch, event handler 9664 // attached to outer element during patch, and triggered again. This 9665 // happens because browsers fire microtask ticks between event propagation. 9666 // the solution is simple: we save the timestamp when a handler is attached, 9667 // and the handler would only fire if the event passed to it was fired 9668 // AFTER it was attached. 9669 if (useMicrotaskFix) { 9670 var attachedTimestamp = currentFlushTimestamp; 9671 var original = handler; 9672 handler = original._wrapper = function (e) { 9673 if ( 9674 // no bubbling, should always fire. 9675 // this is just a safety net in case event.timeStamp is unreliable in 9676 // certain weird environments... 9677 e.target === e.currentTarget || 9678 // event is fired after handler attachment 9679 e.timeStamp >= attachedTimestamp || 9680 // bail for environments that have buggy event.timeStamp implementations 9681 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState 9682 // #9681 QtWebEngine event.timeStamp is negative value 9683 e.timeStamp <= 0 || 9684 // #9448 bail if event is fired in another document in a multi-page 9685 // electron/nw.js app, since event.timeStamp will be using a different 9686 // starting reference 9687 e.target.ownerDocument !== document 9688 ) { 9689 return original.apply(this, arguments) 9690 } 9691 }; 9692 } 9693 target$1.addEventListener( 9694 name, 9695 handler, 9696 supportsPassive 9697 ? { capture: capture, passive: passive } 9698 : capture 9699 ); 9700} 9701 9702function remove$2 ( 9703 name, 9704 handler, 9705 capture, 9706 _target 9707) { 9708 (_target || target$1).removeEventListener( 9709 name, 9710 handler._wrapper || handler, 9711 capture 9712 ); 9713} 9714 9715function updateDOMListeners (oldVnode, vnode) { 9716 if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { 9717 return 9718 } 9719 var on = vnode.data.on || {}; 9720 var oldOn = oldVnode.data.on || {}; 9721 target$1 = vnode.elm; 9722 normalizeEvents(on); 9723 updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context); 9724 target$1 = undefined; 9725} 9726 9727var events = { 9728 create: updateDOMListeners, 9729 update: updateDOMListeners 9730}; 9731 9732/* */ 9733 9734var svgContainer; 9735 9736function updateDOMProps (oldVnode, vnode) { 9737 if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { 9738 return 9739 } 9740 var key, cur; 9741 var elm = vnode.elm; 9742 var oldProps = oldVnode.data.domProps || {}; 9743 var props = vnode.data.domProps || {}; 9744 // clone observed objects, as the user probably wants to mutate it 9745 if (isDef(props.__ob__)) { 9746 props = vnode.data.domProps = extend({}, props); 9747 } 9748 9749 for (key in oldProps) { 9750 if (!(key in props)) { 9751 elm[key] = ''; 9752 } 9753 } 9754 9755 for (key in props) { 9756 cur = props[key]; 9757 // ignore children if the node has textContent or innerHTML, 9758 // as these will throw away existing DOM nodes and cause removal errors 9759 // on subsequent patches (#3360) 9760 if (key === 'textContent' || key === 'innerHTML') { 9761 if (vnode.children) { vnode.children.length = 0; } 9762 if (cur === oldProps[key]) { continue } 9763 // #6601 work around Chrome version <= 55 bug where single textNode 9764 // replaced by innerHTML/textContent retains its parentNode property 9765 if (elm.childNodes.length === 1) { 9766 elm.removeChild(elm.childNodes[0]); 9767 } 9768 } 9769 9770 if (key === 'value' && elm.tagName !== 'PROGRESS') { 9771 // store value as _value as well since 9772 // non-string values will be stringified 9773 elm._value = cur; 9774 // avoid resetting cursor position when value is the same 9775 var strCur = isUndef(cur) ? '' : String(cur); 9776 if (shouldUpdateValue(elm, strCur)) { 9777 elm.value = strCur; 9778 } 9779 } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) { 9780 // IE doesn't support innerHTML for SVG elements 9781 svgContainer = svgContainer || document.createElement('div'); 9782 svgContainer.innerHTML = "<svg>" + cur + "</svg>"; 9783 var svg = svgContainer.firstChild; 9784 while (elm.firstChild) { 9785 elm.removeChild(elm.firstChild); 9786 } 9787 while (svg.firstChild) { 9788 elm.appendChild(svg.firstChild); 9789 } 9790 } else if ( 9791 // skip the update if old and new VDOM state is the same. 9792 // `value` is handled separately because the DOM value may be temporarily 9793 // out of sync with VDOM state due to focus, composition and modifiers. 9794 // This #4521 by skipping the unnecessary `checked` update. 9795 cur !== oldProps[key] 9796 ) { 9797 // some property updates can throw 9798 // e.g. `value` on <progress> w/ non-finite value 9799 try { 9800 elm[key] = cur; 9801 } catch (e) {} 9802 } 9803 } 9804} 9805 9806// check platforms/web/util/attrs.js acceptValue 9807 9808 9809function shouldUpdateValue (elm, checkVal) { 9810 return (!elm.composing && ( 9811 elm.tagName === 'OPTION' || 9812 isNotInFocusAndDirty(elm, checkVal) || 9813 isDirtyWithModifiers(elm, checkVal) 9814 )) 9815} 9816 9817function isNotInFocusAndDirty (elm, checkVal) { 9818 // return true when textbox (.number and .trim) loses focus and its value is 9819 // not equal to the updated value 9820 var notInFocus = true; 9821 // #6157 9822 // work around IE bug when accessing document.activeElement in an iframe 9823 try { notInFocus = document.activeElement !== elm; } catch (e) {} 9824 return notInFocus && elm.value !== checkVal 9825} 9826 9827function isDirtyWithModifiers (elm, newVal) { 9828 var value = elm.value; 9829 var modifiers = elm._vModifiers; // injected by v-model runtime 9830 if (isDef(modifiers)) { 9831 if (modifiers.number) { 9832 return toNumber(value) !== toNumber(newVal) 9833 } 9834 if (modifiers.trim) { 9835 return value.trim() !== newVal.trim() 9836 } 9837 } 9838 return value !== newVal 9839} 9840 9841var domProps = { 9842 create: updateDOMProps, 9843 update: updateDOMProps 9844}; 9845 9846/* */ 9847 9848var parseStyleText = cached(function (cssText) { 9849 var res = {}; 9850 var listDelimiter = /;(?![^(]*\))/g; 9851 var propertyDelimiter = /:(.+)/; 9852 cssText.split(listDelimiter).forEach(function (item) { 9853 if (item) { 9854 var tmp = item.split(propertyDelimiter); 9855 tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); 9856 } 9857 }); 9858 return res 9859}); 9860 9861// merge static and dynamic style data on the same vnode 9862function normalizeStyleData (data) { 9863 var style = normalizeStyleBinding(data.style); 9864 // static style is pre-processed into an object during compilation 9865 // and is always a fresh object, so it's safe to merge into it 9866 return data.staticStyle 9867 ? extend(data.staticStyle, style) 9868 : style 9869} 9870 9871// normalize possible array / string values into Object 9872function normalizeStyleBinding (bindingStyle) { 9873 if (Array.isArray(bindingStyle)) { 9874 return toObject(bindingStyle) 9875 } 9876 if (typeof bindingStyle === 'string') { 9877 return parseStyleText(bindingStyle) 9878 } 9879 return bindingStyle 9880} 9881 9882/** 9883 * parent component style should be after child's 9884 * so that parent component's style could override it 9885 */ 9886function getStyle (vnode, checkChild) { 9887 var res = {}; 9888 var styleData; 9889 9890 if (checkChild) { 9891 var childNode = vnode; 9892 while (childNode.componentInstance) { 9893 childNode = childNode.componentInstance._vnode; 9894 if ( 9895 childNode && childNode.data && 9896 (styleData = normalizeStyleData(childNode.data)) 9897 ) { 9898 extend(res, styleData); 9899 } 9900 } 9901 } 9902 9903 if ((styleData = normalizeStyleData(vnode.data))) { 9904 extend(res, styleData); 9905 } 9906 9907 var parentNode = vnode; 9908 while ((parentNode = parentNode.parent)) { 9909 if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) { 9910 extend(res, styleData); 9911 } 9912 } 9913 return res 9914} 9915 9916/* */ 9917 9918var cssVarRE = /^--/; 9919var importantRE = /\s*!important$/; 9920var setProp = function (el, name, val) { 9921 /* istanbul ignore if */ 9922 if (cssVarRE.test(name)) { 9923 el.style.setProperty(name, val); 9924 } else if (importantRE.test(val)) { 9925 el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important'); 9926 } else { 9927 var normalizedName = normalize(name); 9928 if (Array.isArray(val)) { 9929 // Support values array created by autoprefixer, e.g. 9930 // {display: ["-webkit-box", "-ms-flexbox", "flex"]} 9931 // Set them one by one, and the browser will only set those it can recognize 9932 for (var i = 0, len = val.length; i < len; i++) { 9933 el.style[normalizedName] = val[i]; 9934 } 9935 } else { 9936 el.style[normalizedName] = val; 9937 } 9938 } 9939}; 9940 9941var vendorNames = ['Webkit', 'Moz', 'ms']; 9942 9943var emptyStyle; 9944var normalize = cached(function (prop) { 9945 emptyStyle = emptyStyle || document.createElement('div').style; 9946 prop = camelize(prop); 9947 if (prop !== 'filter' && (prop in emptyStyle)) { 9948 return prop 9949 } 9950 var capName = prop.charAt(0).toUpperCase() + prop.slice(1); 9951 for (var i = 0; i < vendorNames.length; i++) { 9952 var name = vendorNames[i] + capName; 9953 if (name in emptyStyle) { 9954 return name 9955 } 9956 } 9957}); 9958 9959function updateStyle (oldVnode, vnode) { 9960 var data = vnode.data; 9961 var oldData = oldVnode.data; 9962 9963 if (isUndef(data.staticStyle) && isUndef(data.style) && 9964 isUndef(oldData.staticStyle) && isUndef(oldData.style) 9965 ) { 9966 return 9967 } 9968 9969 var cur, name; 9970 var el = vnode.elm; 9971 var oldStaticStyle = oldData.staticStyle; 9972 var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; 9973 9974 // if static style exists, stylebinding already merged into it when doing normalizeStyleData 9975 var oldStyle = oldStaticStyle || oldStyleBinding; 9976 9977 var style = normalizeStyleBinding(vnode.data.style) || {}; 9978 9979 // store normalized style under a different key for next diff 9980 // make sure to clone it if it's reactive, since the user likely wants 9981 // to mutate it. 9982 vnode.data.normalizedStyle = isDef(style.__ob__) 9983 ? extend({}, style) 9984 : style; 9985 9986 var newStyle = getStyle(vnode, true); 9987 9988 for (name in oldStyle) { 9989 if (isUndef(newStyle[name])) { 9990 setProp(el, name, ''); 9991 } 9992 } 9993 for (name in newStyle) { 9994 cur = newStyle[name]; 9995 if (cur !== oldStyle[name]) { 9996 // ie9 setting to null has no effect, must use empty string 9997 setProp(el, name, cur == null ? '' : cur); 9998 } 9999 } 10000} 10001 10002var style = { 10003 create: updateStyle, 10004 update: updateStyle 10005}; 10006 10007/* */ 10008 10009var whitespaceRE = /\s+/; 10010 10011/** 10012 * Add class with compatibility for SVG since classList is not supported on 10013 * SVG elements in IE 10014 */ 10015function addClass (el, cls) { 10016 /* istanbul ignore if */ 10017 if (!cls || !(cls = cls.trim())) { 10018 return 10019 } 10020 10021 /* istanbul ignore else */ 10022 if (el.classList) { 10023 if (cls.indexOf(' ') > -1) { 10024 cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); }); 10025 } else { 10026 el.classList.add(cls); 10027 } 10028 } else { 10029 var cur = " " + (el.getAttribute('class') || '') + " "; 10030 if (cur.indexOf(' ' + cls + ' ') < 0) { 10031 el.setAttribute('class', (cur + cls).trim()); 10032 } 10033 } 10034} 10035 10036/** 10037 * Remove class with compatibility for SVG since classList is not supported on 10038 * SVG elements in IE 10039 */ 10040function removeClass (el, cls) { 10041 /* istanbul ignore if */ 10042 if (!cls || !(cls = cls.trim())) { 10043 return 10044 } 10045 10046 /* istanbul ignore else */ 10047 if (el.classList) { 10048 if (cls.indexOf(' ') > -1) { 10049 cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); }); 10050 } else { 10051 el.classList.remove(cls); 10052 } 10053 if (!el.classList.length) { 10054 el.removeAttribute('class'); 10055 } 10056 } else { 10057 var cur = " " + (el.getAttribute('class') || '') + " "; 10058 var tar = ' ' + cls + ' '; 10059 while (cur.indexOf(tar) >= 0) { 10060 cur = cur.replace(tar, ' '); 10061 } 10062 cur = cur.trim(); 10063 if (cur) { 10064 el.setAttribute('class', cur); 10065 } else { 10066 el.removeAttribute('class'); 10067 } 10068 } 10069} 10070 10071/* */ 10072 10073function resolveTransition (def$$1) { 10074 if (!def$$1) { 10075 return 10076 } 10077 /* istanbul ignore else */ 10078 if (typeof def$$1 === 'object') { 10079 var res = {}; 10080 if (def$$1.css !== false) { 10081 extend(res, autoCssTransition(def$$1.name || 'v')); 10082 } 10083 extend(res, def$$1); 10084 return res 10085 } else if (typeof def$$1 === 'string') { 10086 return autoCssTransition(def$$1) 10087 } 10088} 10089 10090var autoCssTransition = cached(function (name) { 10091 return { 10092 enterClass: (name + "-enter"), 10093 enterToClass: (name + "-enter-to"), 10094 enterActiveClass: (name + "-enter-active"), 10095 leaveClass: (name + "-leave"), 10096 leaveToClass: (name + "-leave-to"), 10097 leaveActiveClass: (name + "-leave-active") 10098 } 10099}); 10100 10101var hasTransition = inBrowser && !isIE9; 10102var TRANSITION = 'transition'; 10103var ANIMATION = 'animation'; 10104 10105// Transition property/event sniffing 10106var transitionProp = 'transition'; 10107var transitionEndEvent = 'transitionend'; 10108var animationProp = 'animation'; 10109var animationEndEvent = 'animationend'; 10110if (hasTransition) { 10111 /* istanbul ignore if */ 10112 if (window.ontransitionend === undefined && 10113 window.onwebkittransitionend !== undefined 10114 ) { 10115 transitionProp = 'WebkitTransition'; 10116 transitionEndEvent = 'webkitTransitionEnd'; 10117 } 10118 if (window.onanimationend === undefined && 10119 window.onwebkitanimationend !== undefined 10120 ) { 10121 animationProp = 'WebkitAnimation'; 10122 animationEndEvent = 'webkitAnimationEnd'; 10123 } 10124} 10125 10126// binding to window is necessary to make hot reload work in IE in strict mode 10127var raf = inBrowser 10128 ? window.requestAnimationFrame 10129 ? window.requestAnimationFrame.bind(window) 10130 : setTimeout 10131 : /* istanbul ignore next */ function (fn) { return fn(); }; 10132 10133function nextFrame (fn) { 10134 raf(function () { 10135 raf(fn); 10136 }); 10137} 10138 10139function addTransitionClass (el, cls) { 10140 var transitionClasses = el._transitionClasses || (el._transitionClasses = []); 10141 if (transitionClasses.indexOf(cls) < 0) { 10142 transitionClasses.push(cls); 10143 addClass(el, cls); 10144 } 10145} 10146 10147function removeTransitionClass (el, cls) { 10148 if (el._transitionClasses) { 10149 remove(el._transitionClasses, cls); 10150 } 10151 removeClass(el, cls); 10152} 10153 10154function whenTransitionEnds ( 10155 el, 10156 expectedType, 10157 cb 10158) { 10159 var ref = getTransitionInfo(el, expectedType); 10160 var type = ref.type; 10161 var timeout = ref.timeout; 10162 var propCount = ref.propCount; 10163 if (!type) { return cb() } 10164 var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; 10165 var ended = 0; 10166 var end = function () { 10167 el.removeEventListener(event, onEnd); 10168 cb(); 10169 }; 10170 var onEnd = function (e) { 10171 if (e.target === el) { 10172 if (++ended >= propCount) { 10173 end(); 10174 } 10175 } 10176 }; 10177 setTimeout(function () { 10178 if (ended < propCount) { 10179 end(); 10180 } 10181 }, timeout + 1); 10182 el.addEventListener(event, onEnd); 10183} 10184 10185var transformRE = /\b(transform|all)(,|$)/; 10186 10187function getTransitionInfo (el, expectedType) { 10188 var styles = window.getComputedStyle(el); 10189 // JSDOM may return undefined for transition properties 10190 var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', '); 10191 var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', '); 10192 var transitionTimeout = getTimeout(transitionDelays, transitionDurations); 10193 var animationDelays = (styles[animationProp + 'Delay'] || '').split(', '); 10194 var animationDurations = (styles[animationProp + 'Duration'] || '').split(', '); 10195 var animationTimeout = getTimeout(animationDelays, animationDurations); 10196 10197 var type; 10198 var timeout = 0; 10199 var propCount = 0; 10200 /* istanbul ignore if */ 10201 if (expectedType === TRANSITION) { 10202 if (transitionTimeout > 0) { 10203 type = TRANSITION; 10204 timeout = transitionTimeout; 10205 propCount = transitionDurations.length; 10206 } 10207 } else if (expectedType === ANIMATION) { 10208 if (animationTimeout > 0) { 10209 type = ANIMATION; 10210 timeout = animationTimeout; 10211 propCount = animationDurations.length; 10212 } 10213 } else { 10214 timeout = Math.max(transitionTimeout, animationTimeout); 10215 type = timeout > 0 10216 ? transitionTimeout > animationTimeout 10217 ? TRANSITION 10218 : ANIMATION 10219 : null; 10220 propCount = type 10221 ? type === TRANSITION 10222 ? transitionDurations.length 10223 : animationDurations.length 10224 : 0; 10225 } 10226 var hasTransform = 10227 type === TRANSITION && 10228 transformRE.test(styles[transitionProp + 'Property']); 10229 return { 10230 type: type, 10231 timeout: timeout, 10232 propCount: propCount, 10233 hasTransform: hasTransform 10234 } 10235} 10236 10237function getTimeout (delays, durations) { 10238 /* istanbul ignore next */ 10239 while (delays.length < durations.length) { 10240 delays = delays.concat(delays); 10241 } 10242 10243 return Math.max.apply(null, durations.map(function (d, i) { 10244 return toMs(d) + toMs(delays[i]) 10245 })) 10246} 10247 10248// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers 10249// in a locale-dependent way, using a comma instead of a dot. 10250// If comma is not replaced with a dot, the input will be rounded down (i.e. acting 10251// as a floor function) causing unexpected behaviors 10252function toMs (s) { 10253 return Number(s.slice(0, -1).replace(',', '.')) * 1000 10254} 10255 10256/* */ 10257 10258function enter (vnode, toggleDisplay) { 10259 var el = vnode.elm; 10260 10261 // call leave callback now 10262 if (isDef(el._leaveCb)) { 10263 el._leaveCb.cancelled = true; 10264 el._leaveCb(); 10265 } 10266 10267 var data = resolveTransition(vnode.data.transition); 10268 if (isUndef(data)) { 10269 return 10270 } 10271 10272 /* istanbul ignore if */ 10273 if (isDef(el._enterCb) || el.nodeType !== 1) { 10274 return 10275 } 10276 10277 var css = data.css; 10278 var type = data.type; 10279 var enterClass = data.enterClass; 10280 var enterToClass = data.enterToClass; 10281 var enterActiveClass = data.enterActiveClass; 10282 var appearClass = data.appearClass; 10283 var appearToClass = data.appearToClass; 10284 var appearActiveClass = data.appearActiveClass; 10285 var beforeEnter = data.beforeEnter; 10286 var enter = data.enter; 10287 var afterEnter = data.afterEnter; 10288 var enterCancelled = data.enterCancelled; 10289 var beforeAppear = data.beforeAppear; 10290 var appear = data.appear; 10291 var afterAppear = data.afterAppear; 10292 var appearCancelled = data.appearCancelled; 10293 var duration = data.duration; 10294 10295 // activeInstance will always be the <transition> component managing this 10296 // transition. One edge case to check is when the <transition> is placed 10297 // as the root node of a child component. In that case we need to check 10298 // <transition>'s parent for appear check. 10299 var context = activeInstance; 10300 var transitionNode = activeInstance.$vnode; 10301 while (transitionNode && transitionNode.parent) { 10302 context = transitionNode.context; 10303 transitionNode = transitionNode.parent; 10304 } 10305 10306 var isAppear = !context._isMounted || !vnode.isRootInsert; 10307 10308 if (isAppear && !appear && appear !== '') { 10309 return 10310 } 10311 10312 var startClass = isAppear && appearClass 10313 ? appearClass 10314 : enterClass; 10315 var activeClass = isAppear && appearActiveClass 10316 ? appearActiveClass 10317 : enterActiveClass; 10318 var toClass = isAppear && appearToClass 10319 ? appearToClass 10320 : enterToClass; 10321 10322 var beforeEnterHook = isAppear 10323 ? (beforeAppear || beforeEnter) 10324 : beforeEnter; 10325 var enterHook = isAppear 10326 ? (typeof appear === 'function' ? appear : enter) 10327 : enter; 10328 var afterEnterHook = isAppear 10329 ? (afterAppear || afterEnter) 10330 : afterEnter; 10331 var enterCancelledHook = isAppear 10332 ? (appearCancelled || enterCancelled) 10333 : enterCancelled; 10334 10335 var explicitEnterDuration = toNumber( 10336 isObject(duration) 10337 ? duration.enter 10338 : duration 10339 ); 10340 10341 if (explicitEnterDuration != null) { 10342 checkDuration(explicitEnterDuration, 'enter', vnode); 10343 } 10344 10345 var expectsCSS = css !== false && !isIE9; 10346 var userWantsControl = getHookArgumentsLength(enterHook); 10347 10348 var cb = el._enterCb = once(function () { 10349 if (expectsCSS) { 10350 removeTransitionClass(el, toClass); 10351 removeTransitionClass(el, activeClass); 10352 } 10353 if (cb.cancelled) { 10354 if (expectsCSS) { 10355 removeTransitionClass(el, startClass); 10356 } 10357 enterCancelledHook && enterCancelledHook(el); 10358 } else { 10359 afterEnterHook && afterEnterHook(el); 10360 } 10361 el._enterCb = null; 10362 }); 10363 10364 if (!vnode.data.show) { 10365 // remove pending leave element on enter by injecting an insert hook 10366 mergeVNodeHook(vnode, 'insert', function () { 10367 var parent = el.parentNode; 10368 var pendingNode = parent && parent._pending && parent._pending[vnode.key]; 10369 if (pendingNode && 10370 pendingNode.tag === vnode.tag && 10371 pendingNode.elm._leaveCb 10372 ) { 10373 pendingNode.elm._leaveCb(); 10374 } 10375 enterHook && enterHook(el, cb); 10376 }); 10377 } 10378 10379 // start enter transition 10380 beforeEnterHook && beforeEnterHook(el); 10381 if (expectsCSS) { 10382 addTransitionClass(el, startClass); 10383 addTransitionClass(el, activeClass); 10384 nextFrame(function () { 10385 removeTransitionClass(el, startClass); 10386 if (!cb.cancelled) { 10387 addTransitionClass(el, toClass); 10388 if (!userWantsControl) { 10389 if (isValidDuration(explicitEnterDuration)) { 10390 setTimeout(cb, explicitEnterDuration); 10391 } else { 10392 whenTransitionEnds(el, type, cb); 10393 } 10394 } 10395 } 10396 }); 10397 } 10398 10399 if (vnode.data.show) { 10400 toggleDisplay && toggleDisplay(); 10401 enterHook && enterHook(el, cb); 10402 } 10403 10404 if (!expectsCSS && !userWantsControl) { 10405 cb(); 10406 } 10407} 10408 10409function leave (vnode, rm) { 10410 var el = vnode.elm; 10411 10412 // call enter callback now 10413 if (isDef(el._enterCb)) { 10414 el._enterCb.cancelled = true; 10415 el._enterCb(); 10416 } 10417 10418 var data = resolveTransition(vnode.data.transition); 10419 if (isUndef(data) || el.nodeType !== 1) { 10420 return rm() 10421 } 10422 10423 /* istanbul ignore if */ 10424 if (isDef(el._leaveCb)) { 10425 return 10426 } 10427 10428 var css = data.css; 10429 var type = data.type; 10430 var leaveClass = data.leaveClass; 10431 var leaveToClass = data.leaveToClass; 10432 var leaveActiveClass = data.leaveActiveClass; 10433 var beforeLeave = data.beforeLeave; 10434 var leave = data.leave; 10435 var afterLeave = data.afterLeave; 10436 var leaveCancelled = data.leaveCancelled; 10437 var delayLeave = data.delayLeave; 10438 var duration = data.duration; 10439 10440 var expectsCSS = css !== false && !isIE9; 10441 var userWantsControl = getHookArgumentsLength(leave); 10442 10443 var explicitLeaveDuration = toNumber( 10444 isObject(duration) 10445 ? duration.leave 10446 : duration 10447 ); 10448 10449 if (isDef(explicitLeaveDuration)) { 10450 checkDuration(explicitLeaveDuration, 'leave', vnode); 10451 } 10452 10453 var cb = el._leaveCb = once(function () { 10454 if (el.parentNode && el.parentNode._pending) { 10455 el.parentNode._pending[vnode.key] = null; 10456 } 10457 if (expectsCSS) { 10458 removeTransitionClass(el, leaveToClass); 10459 removeTransitionClass(el, leaveActiveClass); 10460 } 10461 if (cb.cancelled) { 10462 if (expectsCSS) { 10463 removeTransitionClass(el, leaveClass); 10464 } 10465 leaveCancelled && leaveCancelled(el); 10466 } else { 10467 rm(); 10468 afterLeave && afterLeave(el); 10469 } 10470 el._leaveCb = null; 10471 }); 10472 10473 if (delayLeave) { 10474 delayLeave(performLeave); 10475 } else { 10476 performLeave(); 10477 } 10478 10479 function performLeave () { 10480 // the delayed leave may have already been cancelled 10481 if (cb.cancelled) { 10482 return 10483 } 10484 // record leaving element 10485 if (!vnode.data.show && el.parentNode) { 10486 (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode; 10487 } 10488 beforeLeave && beforeLeave(el); 10489 if (expectsCSS) { 10490 addTransitionClass(el, leaveClass); 10491 addTransitionClass(el, leaveActiveClass); 10492 nextFrame(function () { 10493 removeTransitionClass(el, leaveClass); 10494 if (!cb.cancelled) { 10495 addTransitionClass(el, leaveToClass); 10496 if (!userWantsControl) { 10497 if (isValidDuration(explicitLeaveDuration)) { 10498 setTimeout(cb, explicitLeaveDuration); 10499 } else { 10500 whenTransitionEnds(el, type, cb); 10501 } 10502 } 10503 } 10504 }); 10505 } 10506 leave && leave(el, cb); 10507 if (!expectsCSS && !userWantsControl) { 10508 cb(); 10509 } 10510 } 10511} 10512 10513// only used in dev mode 10514function checkDuration (val, name, vnode) { 10515 if (typeof val !== 'number') { 10516 warn( 10517 "<transition> explicit " + name + " duration is not a valid number - " + 10518 "got " + (JSON.stringify(val)) + ".", 10519 vnode.context 10520 ); 10521 } else if (isNaN(val)) { 10522 warn( 10523 "<transition> explicit " + name + " duration is NaN - " + 10524 'the duration expression might be incorrect.', 10525 vnode.context 10526 ); 10527 } 10528} 10529 10530function isValidDuration (val) { 10531 return typeof val === 'number' && !isNaN(val) 10532} 10533 10534/** 10535 * Normalize a transition hook's argument length. The hook may be: 10536 * - a merged hook (invoker) with the original in .fns 10537 * - a wrapped component method (check ._length) 10538 * - a plain function (.length) 10539 */ 10540function getHookArgumentsLength (fn) { 10541 if (isUndef(fn)) { 10542 return false 10543 } 10544 var invokerFns = fn.fns; 10545 if (isDef(invokerFns)) { 10546 // invoker 10547 return getHookArgumentsLength( 10548 Array.isArray(invokerFns) 10549 ? invokerFns[0] 10550 : invokerFns 10551 ) 10552 } else { 10553 return (fn._length || fn.length) > 1 10554 } 10555} 10556 10557function _enter (_, vnode) { 10558 if (vnode.data.show !== true) { 10559 enter(vnode); 10560 } 10561} 10562 10563var transition = inBrowser ? { 10564 create: _enter, 10565 activate: _enter, 10566 remove: function remove$$1 (vnode, rm) { 10567 /* istanbul ignore else */ 10568 if (vnode.data.show !== true) { 10569 leave(vnode, rm); 10570 } else { 10571 rm(); 10572 } 10573 } 10574} : {}; 10575 10576var platformModules = [ 10577 attrs, 10578 klass, 10579 events, 10580 domProps, 10581 style, 10582 transition 10583]; 10584 10585/* */ 10586 10587// the directive module should be applied last, after all 10588// built-in modules have been applied. 10589var modules = platformModules.concat(baseModules); 10590 10591var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules }); 10592 10593/** 10594 * Not type checking this file because flow doesn't like attaching 10595 * properties to Elements. 10596 */ 10597 10598/* istanbul ignore if */ 10599if (isIE9) { 10600 // http://www.matts411.com/post/internet-explorer-9-oninput/ 10601 document.addEventListener('selectionchange', function () { 10602 var el = document.activeElement; 10603 if (el && el.vmodel) { 10604 trigger(el, 'input'); 10605 } 10606 }); 10607} 10608 10609var directive = { 10610 inserted: function inserted (el, binding, vnode, oldVnode) { 10611 if (vnode.tag === 'select') { 10612 // #6903 10613 if (oldVnode.elm && !oldVnode.elm._vOptions) { 10614 mergeVNodeHook(vnode, 'postpatch', function () { 10615 directive.componentUpdated(el, binding, vnode); 10616 }); 10617 } else { 10618 setSelected(el, binding, vnode.context); 10619 } 10620 el._vOptions = [].map.call(el.options, getValue); 10621 } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) { 10622 el._vModifiers = binding.modifiers; 10623 if (!binding.modifiers.lazy) { 10624 el.addEventListener('compositionstart', onCompositionStart); 10625 el.addEventListener('compositionend', onCompositionEnd); 10626 // Safari < 10.2 & UIWebView doesn't fire compositionend when 10627 // switching focus before confirming composition choice 10628 // this also fixes the issue where some browsers e.g. iOS Chrome 10629 // fires "change" instead of "input" on autocomplete. 10630 el.addEventListener('change', onCompositionEnd); 10631 /* istanbul ignore if */ 10632 if (isIE9) { 10633 el.vmodel = true; 10634 } 10635 } 10636 } 10637 }, 10638 10639 componentUpdated: function componentUpdated (el, binding, vnode) { 10640 if (vnode.tag === 'select') { 10641 setSelected(el, binding, vnode.context); 10642 // in case the options rendered by v-for have changed, 10643 // it's possible that the value is out-of-sync with the rendered options. 10644 // detect such cases and filter out values that no longer has a matching 10645 // option in the DOM. 10646 var prevOptions = el._vOptions; 10647 var curOptions = el._vOptions = [].map.call(el.options, getValue); 10648 if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) { 10649 // trigger change event if 10650 // no matching option found for at least one value 10651 var needReset = el.multiple 10652 ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); }) 10653 : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions); 10654 if (needReset) { 10655 trigger(el, 'change'); 10656 } 10657 } 10658 } 10659 } 10660}; 10661 10662function setSelected (el, binding, vm) { 10663 actuallySetSelected(el, binding, vm); 10664 /* istanbul ignore if */ 10665 if (isIE || isEdge) { 10666 setTimeout(function () { 10667 actuallySetSelected(el, binding, vm); 10668 }, 0); 10669 } 10670} 10671 10672function actuallySetSelected (el, binding, vm) { 10673 var value = binding.value; 10674 var isMultiple = el.multiple; 10675 if (isMultiple && !Array.isArray(value)) { 10676 warn( 10677 "<select multiple v-model=\"" + (binding.expression) + "\"> " + 10678 "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)), 10679 vm 10680 ); 10681 return 10682 } 10683 var selected, option; 10684 for (var i = 0, l = el.options.length; i < l; i++) { 10685 option = el.options[i]; 10686 if (isMultiple) { 10687 selected = looseIndexOf(value, getValue(option)) > -1; 10688 if (option.selected !== selected) { 10689 option.selected = selected; 10690 } 10691 } else { 10692 if (looseEqual(getValue(option), value)) { 10693 if (el.selectedIndex !== i) { 10694 el.selectedIndex = i; 10695 } 10696 return 10697 } 10698 } 10699 } 10700 if (!isMultiple) { 10701 el.selectedIndex = -1; 10702 } 10703} 10704 10705function hasNoMatchingOption (value, options) { 10706 return options.every(function (o) { return !looseEqual(o, value); }) 10707} 10708 10709function getValue (option) { 10710 return '_value' in option 10711 ? option._value 10712 : option.value 10713} 10714 10715function onCompositionStart (e) { 10716 e.target.composing = true; 10717} 10718 10719function onCompositionEnd (e) { 10720 // prevent triggering an input event for no reason 10721 if (!e.target.composing) { return } 10722 e.target.composing = false; 10723 trigger(e.target, 'input'); 10724} 10725 10726function trigger (el, type) { 10727 var e = document.createEvent('HTMLEvents'); 10728 e.initEvent(type, true, true); 10729 el.dispatchEvent(e); 10730} 10731 10732/* */ 10733 10734// recursively search for possible transition defined inside the component root 10735function locateNode (vnode) { 10736 return vnode.componentInstance && (!vnode.data || !vnode.data.transition) 10737 ? locateNode(vnode.componentInstance._vnode) 10738 : vnode 10739} 10740 10741var show = { 10742 bind: function bind (el, ref, vnode) { 10743 var value = ref.value; 10744 10745 vnode = locateNode(vnode); 10746 var transition$$1 = vnode.data && vnode.data.transition; 10747 var originalDisplay = el.__vOriginalDisplay = 10748 el.style.display === 'none' ? '' : el.style.display; 10749 if (value && transition$$1) { 10750 vnode.data.show = true; 10751 enter(vnode, function () { 10752 el.style.display = originalDisplay; 10753 }); 10754 } else { 10755 el.style.display = value ? originalDisplay : 'none'; 10756 } 10757 }, 10758 10759 update: function update (el, ref, vnode) { 10760 var value = ref.value; 10761 var oldValue = ref.oldValue; 10762 10763 /* istanbul ignore if */ 10764 if (!value === !oldValue) { return } 10765 vnode = locateNode(vnode); 10766 var transition$$1 = vnode.data && vnode.data.transition; 10767 if (transition$$1) { 10768 vnode.data.show = true; 10769 if (value) { 10770 enter(vnode, function () { 10771 el.style.display = el.__vOriginalDisplay; 10772 }); 10773 } else { 10774 leave(vnode, function () { 10775 el.style.display = 'none'; 10776 }); 10777 } 10778 } else { 10779 el.style.display = value ? el.__vOriginalDisplay : 'none'; 10780 } 10781 }, 10782 10783 unbind: function unbind ( 10784 el, 10785 binding, 10786 vnode, 10787 oldVnode, 10788 isDestroy 10789 ) { 10790 if (!isDestroy) { 10791 el.style.display = el.__vOriginalDisplay; 10792 } 10793 } 10794}; 10795 10796var platformDirectives = { 10797 model: directive, 10798 show: show 10799}; 10800 10801/* */ 10802 10803var transitionProps = { 10804 name: String, 10805 appear: Boolean, 10806 css: Boolean, 10807 mode: String, 10808 type: String, 10809 enterClass: String, 10810 leaveClass: String, 10811 enterToClass: String, 10812 leaveToClass: String, 10813 enterActiveClass: String, 10814 leaveActiveClass: String, 10815 appearClass: String, 10816 appearActiveClass: String, 10817 appearToClass: String, 10818 duration: [Number, String, Object] 10819}; 10820 10821// in case the child is also an abstract component, e.g. <keep-alive> 10822// we want to recursively retrieve the real component to be rendered 10823function getRealChild (vnode) { 10824 var compOptions = vnode && vnode.componentOptions; 10825 if (compOptions && compOptions.Ctor.options.abstract) { 10826 return getRealChild(getFirstComponentChild(compOptions.children)) 10827 } else { 10828 return vnode 10829 } 10830} 10831 10832function extractTransitionData (comp) { 10833 var data = {}; 10834 var options = comp.$options; 10835 // props 10836 for (var key in options.propsData) { 10837 data[key] = comp[key]; 10838 } 10839 // events. 10840 // extract listeners and pass them directly to the transition methods 10841 var listeners = options._parentListeners; 10842 for (var key$1 in listeners) { 10843 data[camelize(key$1)] = listeners[key$1]; 10844 } 10845 return data 10846} 10847 10848function placeholder (h, rawChild) { 10849 if (/\d-keep-alive$/.test(rawChild.tag)) { 10850 return h('keep-alive', { 10851 props: rawChild.componentOptions.propsData 10852 }) 10853 } 10854} 10855 10856function hasParentTransition (vnode) { 10857 while ((vnode = vnode.parent)) { 10858 if (vnode.data.transition) { 10859 return true 10860 } 10861 } 10862} 10863 10864function isSameChild (child, oldChild) { 10865 return oldChild.key === child.key && oldChild.tag === child.tag 10866} 10867 10868var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); }; 10869 10870var isVShowDirective = function (d) { return d.name === 'show'; }; 10871 10872var Transition = { 10873 name: 'transition', 10874 props: transitionProps, 10875 abstract: true, 10876 10877 render: function render (h) { 10878 var this$1 = this; 10879 10880 var children = this.$slots.default; 10881 if (!children) { 10882 return 10883 } 10884 10885 // filter out text nodes (possible whitespaces) 10886 children = children.filter(isNotTextNode); 10887 /* istanbul ignore if */ 10888 if (!children.length) { 10889 return 10890 } 10891 10892 // warn multiple elements 10893 if (children.length > 1) { 10894 warn( 10895 '<transition> can only be used on a single element. Use ' + 10896 '<transition-group> for lists.', 10897 this.$parent 10898 ); 10899 } 10900 10901 var mode = this.mode; 10902 10903 // warn invalid mode 10904 if (mode && mode !== 'in-out' && mode !== 'out-in' 10905 ) { 10906 warn( 10907 'invalid <transition> mode: ' + mode, 10908 this.$parent 10909 ); 10910 } 10911 10912 var rawChild = children[0]; 10913 10914 // if this is a component root node and the component's 10915 // parent container node also has transition, skip. 10916 if (hasParentTransition(this.$vnode)) { 10917 return rawChild 10918 } 10919 10920 // apply transition data to child 10921 // use getRealChild() to ignore abstract components e.g. keep-alive 10922 var child = getRealChild(rawChild); 10923 /* istanbul ignore if */ 10924 if (!child) { 10925 return rawChild 10926 } 10927 10928 if (this._leaving) { 10929 return placeholder(h, rawChild) 10930 } 10931 10932 // ensure a key that is unique to the vnode type and to this transition 10933 // component instance. This key will be used to remove pending leaving nodes 10934 // during entering. 10935 var id = "__transition-" + (this._uid) + "-"; 10936 child.key = child.key == null 10937 ? child.isComment 10938 ? id + 'comment' 10939 : id + child.tag 10940 : isPrimitive(child.key) 10941 ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key) 10942 : child.key; 10943 10944 var data = (child.data || (child.data = {})).transition = extractTransitionData(this); 10945 var oldRawChild = this._vnode; 10946 var oldChild = getRealChild(oldRawChild); 10947 10948 // mark v-show 10949 // so that the transition module can hand over the control to the directive 10950 if (child.data.directives && child.data.directives.some(isVShowDirective)) { 10951 child.data.show = true; 10952 } 10953 10954 if ( 10955 oldChild && 10956 oldChild.data && 10957 !isSameChild(child, oldChild) && 10958 !isAsyncPlaceholder(oldChild) && 10959 // #6687 component root is a comment node 10960 !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment) 10961 ) { 10962 // replace old child transition data with fresh one 10963 // important for dynamic transitions! 10964 var oldData = oldChild.data.transition = extend({}, data); 10965 // handle transition mode 10966 if (mode === 'out-in') { 10967 // return placeholder node and queue update when leave finishes 10968 this._leaving = true; 10969 mergeVNodeHook(oldData, 'afterLeave', function () { 10970 this$1._leaving = false; 10971 this$1.$forceUpdate(); 10972 }); 10973 return placeholder(h, rawChild) 10974 } else if (mode === 'in-out') { 10975 if (isAsyncPlaceholder(child)) { 10976 return oldRawChild 10977 } 10978 var delayedLeave; 10979 var performLeave = function () { delayedLeave(); }; 10980 mergeVNodeHook(data, 'afterEnter', performLeave); 10981 mergeVNodeHook(data, 'enterCancelled', performLeave); 10982 mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; }); 10983 } 10984 } 10985 10986 return rawChild 10987 } 10988}; 10989 10990/* */ 10991 10992var props = extend({ 10993 tag: String, 10994 moveClass: String 10995}, transitionProps); 10996 10997delete props.mode; 10998 10999var TransitionGroup = { 11000 props: props, 11001 11002 beforeMount: function beforeMount () { 11003 var this$1 = this; 11004 11005 var update = this._update; 11006 this._update = function (vnode, hydrating) { 11007 var restoreActiveInstance = setActiveInstance(this$1); 11008 // force removing pass 11009 this$1.__patch__( 11010 this$1._vnode, 11011 this$1.kept, 11012 false, // hydrating 11013 true // removeOnly (!important, avoids unnecessary moves) 11014 ); 11015 this$1._vnode = this$1.kept; 11016 restoreActiveInstance(); 11017 update.call(this$1, vnode, hydrating); 11018 }; 11019 }, 11020 11021 render: function render (h) { 11022 var tag = this.tag || this.$vnode.data.tag || 'span'; 11023 var map = Object.create(null); 11024 var prevChildren = this.prevChildren = this.children; 11025 var rawChildren = this.$slots.default || []; 11026 var children = this.children = []; 11027 var transitionData = extractTransitionData(this); 11028 11029 for (var i = 0; i < rawChildren.length; i++) { 11030 var c = rawChildren[i]; 11031 if (c.tag) { 11032 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) { 11033 children.push(c); 11034 map[c.key] = c 11035 ;(c.data || (c.data = {})).transition = transitionData; 11036 } else { 11037 var opts = c.componentOptions; 11038 var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag; 11039 warn(("<transition-group> children must be keyed: <" + name + ">")); 11040 } 11041 } 11042 } 11043 11044 if (prevChildren) { 11045 var kept = []; 11046 var removed = []; 11047 for (var i$1 = 0; i$1 < prevChildren.length; i$1++) { 11048 var c$1 = prevChildren[i$1]; 11049 c$1.data.transition = transitionData; 11050 c$1.data.pos = c$1.elm.getBoundingClientRect(); 11051 if (map[c$1.key]) { 11052 kept.push(c$1); 11053 } else { 11054 removed.push(c$1); 11055 } 11056 } 11057 this.kept = h(tag, null, kept); 11058 this.removed = removed; 11059 } 11060 11061 return h(tag, null, children) 11062 }, 11063 11064 updated: function updated () { 11065 var children = this.prevChildren; 11066 var moveClass = this.moveClass || ((this.name || 'v') + '-move'); 11067 if (!children.length || !this.hasMove(children[0].elm, moveClass)) { 11068 return 11069 } 11070 11071 // we divide the work into three loops to avoid mixing DOM reads and writes 11072 // in each iteration - which helps prevent layout thrashing. 11073 children.forEach(callPendingCbs); 11074 children.forEach(recordPosition); 11075 children.forEach(applyTranslation); 11076 11077 // force reflow to put everything in position 11078 // assign to this to avoid being removed in tree-shaking 11079 // $flow-disable-line 11080 this._reflow = document.body.offsetHeight; 11081 11082 children.forEach(function (c) { 11083 if (c.data.moved) { 11084 var el = c.elm; 11085 var s = el.style; 11086 addTransitionClass(el, moveClass); 11087 s.transform = s.WebkitTransform = s.transitionDuration = ''; 11088 el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) { 11089 if (e && e.target !== el) { 11090 return 11091 } 11092 if (!e || /transform$/.test(e.propertyName)) { 11093 el.removeEventListener(transitionEndEvent, cb); 11094 el._moveCb = null; 11095 removeTransitionClass(el, moveClass); 11096 } 11097 }); 11098 } 11099 }); 11100 }, 11101 11102 methods: { 11103 hasMove: function hasMove (el, moveClass) { 11104 /* istanbul ignore if */ 11105 if (!hasTransition) { 11106 return false 11107 } 11108 /* istanbul ignore if */ 11109 if (this._hasMove) { 11110 return this._hasMove 11111 } 11112 // Detect whether an element with the move class applied has 11113 // CSS transitions. Since the element may be inside an entering 11114 // transition at this very moment, we make a clone of it and remove 11115 // all other transition classes applied to ensure only the move class 11116 // is applied. 11117 var clone = el.cloneNode(); 11118 if (el._transitionClasses) { 11119 el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); }); 11120 } 11121 addClass(clone, moveClass); 11122 clone.style.display = 'none'; 11123 this.$el.appendChild(clone); 11124 var info = getTransitionInfo(clone); 11125 this.$el.removeChild(clone); 11126 return (this._hasMove = info.hasTransform) 11127 } 11128 } 11129}; 11130 11131function callPendingCbs (c) { 11132 /* istanbul ignore if */ 11133 if (c.elm._moveCb) { 11134 c.elm._moveCb(); 11135 } 11136 /* istanbul ignore if */ 11137 if (c.elm._enterCb) { 11138 c.elm._enterCb(); 11139 } 11140} 11141 11142function recordPosition (c) { 11143 c.data.newPos = c.elm.getBoundingClientRect(); 11144} 11145 11146function applyTranslation (c) { 11147 var oldPos = c.data.pos; 11148 var newPos = c.data.newPos; 11149 var dx = oldPos.left - newPos.left; 11150 var dy = oldPos.top - newPos.top; 11151 if (dx || dy) { 11152 c.data.moved = true; 11153 var s = c.elm.style; 11154 s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)"; 11155 s.transitionDuration = '0s'; 11156 } 11157} 11158 11159var platformComponents = { 11160 Transition: Transition, 11161 TransitionGroup: TransitionGroup 11162}; 11163 11164/* */ 11165 11166// install platform specific utils 11167Vue.config.mustUseProp = mustUseProp; 11168Vue.config.isReservedTag = isReservedTag; 11169Vue.config.isReservedAttr = isReservedAttr; 11170Vue.config.getTagNamespace = getTagNamespace; 11171Vue.config.isUnknownElement = isUnknownElement; 11172 11173// install platform runtime directives & components 11174extend(Vue.options.directives, platformDirectives); 11175extend(Vue.options.components, platformComponents); 11176 11177// install platform patch function 11178Vue.prototype.__patch__ = inBrowser ? patch : noop; 11179 11180// public mount method 11181Vue.prototype.$mount = function ( 11182 el, 11183 hydrating 11184) { 11185 el = el && inBrowser ? query(el) : undefined; 11186 return mountComponent(this, el, hydrating) 11187}; 11188 11189// devtools global hook 11190/* istanbul ignore next */ 11191if (inBrowser) { 11192 setTimeout(function () { 11193 if (config.devtools) { 11194 if (devtools) { 11195 devtools.emit('init', Vue); 11196 } else { 11197 console[console.info ? 'info' : 'log']( 11198 'Download the Vue Devtools extension for a better development experience:\n' + 11199 'https://github.com/vuejs/vue-devtools' 11200 ); 11201 } 11202 } 11203 if (config.productionTip !== false && 11204 typeof console !== 'undefined' 11205 ) { 11206 console[console.info ? 'info' : 'log']( 11207 "You are running Vue in development mode.\n" + 11208 "Make sure to turn on production mode when deploying for production.\n" + 11209 "See more tips at https://vuejs.org/guide/deployment.html" 11210 ); 11211 } 11212 }, 0); 11213} 11214 11215/* */ 11216 11217var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g; 11218var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g; 11219 11220var buildRegex = cached(function (delimiters) { 11221 var open = delimiters[0].replace(regexEscapeRE, '\\$&'); 11222 var close = delimiters[1].replace(regexEscapeRE, '\\$&'); 11223 return new RegExp(open + '((?:.|\\n)+?)' + close, 'g') 11224}); 11225 11226 11227 11228function parseText ( 11229 text, 11230 delimiters 11231) { 11232 var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; 11233 if (!tagRE.test(text)) { 11234 return 11235 } 11236 var tokens = []; 11237 var rawTokens = []; 11238 var lastIndex = tagRE.lastIndex = 0; 11239 var match, index, tokenValue; 11240 while ((match = tagRE.exec(text))) { 11241 index = match.index; 11242 // push text token 11243 if (index > lastIndex) { 11244 rawTokens.push(tokenValue = text.slice(lastIndex, index)); 11245 tokens.push(JSON.stringify(tokenValue)); 11246 } 11247 // tag token 11248 var exp = parseFilters(match[1].trim()); 11249 tokens.push(("_s(" + exp + ")")); 11250 rawTokens.push({ '@binding': exp }); 11251 lastIndex = index + match[0].length; 11252 } 11253 if (lastIndex < text.length) { 11254 rawTokens.push(tokenValue = text.slice(lastIndex)); 11255 tokens.push(JSON.stringify(tokenValue)); 11256 } 11257 return { 11258 expression: tokens.join('+'), 11259 tokens: rawTokens 11260 } 11261} 11262 11263/* */ 11264 11265function transformNode (el, options) { 11266 var warn = options.warn || baseWarn; 11267 var staticClass = getAndRemoveAttr(el, 'class'); 11268 if (staticClass) { 11269 var res = parseText(staticClass, options.delimiters); 11270 if (res) { 11271 warn( 11272 "class=\"" + staticClass + "\": " + 11273 'Interpolation inside attributes has been removed. ' + 11274 'Use v-bind or the colon shorthand instead. For example, ' + 11275 'instead of <div class="{{ val }}">, use <div :class="val">.', 11276 el.rawAttrsMap['class'] 11277 ); 11278 } 11279 } 11280 if (staticClass) { 11281 el.staticClass = JSON.stringify(staticClass); 11282 } 11283 var classBinding = getBindingAttr(el, 'class', false /* getStatic */); 11284 if (classBinding) { 11285 el.classBinding = classBinding; 11286 } 11287} 11288 11289function genData (el) { 11290 var data = ''; 11291 if (el.staticClass) { 11292 data += "staticClass:" + (el.staticClass) + ","; 11293 } 11294 if (el.classBinding) { 11295 data += "class:" + (el.classBinding) + ","; 11296 } 11297 return data 11298} 11299 11300var klass$1 = { 11301 staticKeys: ['staticClass'], 11302 transformNode: transformNode, 11303 genData: genData 11304}; 11305 11306/* */ 11307 11308function transformNode$1 (el, options) { 11309 var warn = options.warn || baseWarn; 11310 var staticStyle = getAndRemoveAttr(el, 'style'); 11311 if (staticStyle) { 11312 /* istanbul ignore if */ 11313 { 11314 var res = parseText(staticStyle, options.delimiters); 11315 if (res) { 11316 warn( 11317 "style=\"" + staticStyle + "\": " + 11318 'Interpolation inside attributes has been removed. ' + 11319 'Use v-bind or the colon shorthand instead. For example, ' + 11320 'instead of <div style="{{ val }}">, use <div :style="val">.', 11321 el.rawAttrsMap['style'] 11322 ); 11323 } 11324 } 11325 el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); 11326 } 11327 11328 var styleBinding = getBindingAttr(el, 'style', false /* getStatic */); 11329 if (styleBinding) { 11330 el.styleBinding = styleBinding; 11331 } 11332} 11333 11334function genData$1 (el) { 11335 var data = ''; 11336 if (el.staticStyle) { 11337 data += "staticStyle:" + (el.staticStyle) + ","; 11338 } 11339 if (el.styleBinding) { 11340 data += "style:(" + (el.styleBinding) + "),"; 11341 } 11342 return data 11343} 11344 11345var style$1 = { 11346 staticKeys: ['staticStyle'], 11347 transformNode: transformNode$1, 11348 genData: genData$1 11349}; 11350 11351/* */ 11352 11353var decoder; 11354 11355var he = { 11356 decode: function decode (html) { 11357 decoder = decoder || document.createElement('div'); 11358 decoder.innerHTML = html; 11359 return decoder.textContent 11360 } 11361}; 11362 11363/* */ 11364 11365var isUnaryTag = makeMap( 11366 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 11367 'link,meta,param,source,track,wbr' 11368); 11369 11370// Elements that you can, intentionally, leave open 11371// (and which close themselves) 11372var canBeLeftOpenTag = makeMap( 11373 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source' 11374); 11375 11376// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 11377// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content 11378var isNonPhrasingTag = makeMap( 11379 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 11380 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 11381 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 11382 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 11383 'title,tr,track' 11384); 11385 11386/** 11387 * Not type-checking this file because it's mostly vendor code. 11388 */ 11389 11390// Regular Expressions for parsing tags and attributes 11391var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 11392var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/; 11393var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*"; 11394var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")"; 11395var startTagOpen = new RegExp(("^<" + qnameCapture)); 11396var startTagClose = /^\s*(\/?)>/; 11397var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>")); 11398var doctype = /^<!DOCTYPE [^>]+>/i; 11399// #7298: escape - to avoid being passed as HTML comment when inlined in page 11400var comment = /^<!\--/; 11401var conditionalComment = /^<!\[/; 11402 11403// Special Elements (can contain anything) 11404var isPlainTextElement = makeMap('script,style,textarea', true); 11405var reCache = {}; 11406 11407var decodingMap = { 11408 '<': '<', 11409 '>': '>', 11410 '"': '"', 11411 '&': '&', 11412 ' ': '\n', 11413 '	': '\t', 11414 ''': "'" 11415}; 11416var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g; 11417var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g; 11418 11419// #5992 11420var isIgnoreNewlineTag = makeMap('pre,textarea', true); 11421var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; }; 11422 11423function decodeAttr (value, shouldDecodeNewlines) { 11424 var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; 11425 return value.replace(re, function (match) { return decodingMap[match]; }) 11426} 11427 11428function parseHTML (html, options) { 11429 var stack = []; 11430 var expectHTML = options.expectHTML; 11431 var isUnaryTag$$1 = options.isUnaryTag || no; 11432 var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; 11433 var index = 0; 11434 var last, lastTag; 11435 while (html) { 11436 last = html; 11437 // Make sure we're not in a plaintext content element like script/style 11438 if (!lastTag || !isPlainTextElement(lastTag)) { 11439 var textEnd = html.indexOf('<'); 11440 if (textEnd === 0) { 11441 // Comment: 11442 if (comment.test(html)) { 11443 var commentEnd = html.indexOf('-->'); 11444 11445 if (commentEnd >= 0) { 11446 if (options.shouldKeepComment) { 11447 options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3); 11448 } 11449 advance(commentEnd + 3); 11450 continue 11451 } 11452 } 11453 11454 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment 11455 if (conditionalComment.test(html)) { 11456 var conditionalEnd = html.indexOf(']>'); 11457 11458 if (conditionalEnd >= 0) { 11459 advance(conditionalEnd + 2); 11460 continue 11461 } 11462 } 11463 11464 // Doctype: 11465 var doctypeMatch = html.match(doctype); 11466 if (doctypeMatch) { 11467 advance(doctypeMatch[0].length); 11468 continue 11469 } 11470 11471 // End tag: 11472 var endTagMatch = html.match(endTag); 11473 if (endTagMatch) { 11474 var curIndex = index; 11475 advance(endTagMatch[0].length); 11476 parseEndTag(endTagMatch[1], curIndex, index); 11477 continue 11478 } 11479 11480 // Start tag: 11481 var startTagMatch = parseStartTag(); 11482 if (startTagMatch) { 11483 handleStartTag(startTagMatch); 11484 if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) { 11485 advance(1); 11486 } 11487 continue 11488 } 11489 } 11490 11491 var text = (void 0), rest = (void 0), next = (void 0); 11492 if (textEnd >= 0) { 11493 rest = html.slice(textEnd); 11494 while ( 11495 !endTag.test(rest) && 11496 !startTagOpen.test(rest) && 11497 !comment.test(rest) && 11498 !conditionalComment.test(rest) 11499 ) { 11500 // < in plain text, be forgiving and treat it as text 11501 next = rest.indexOf('<', 1); 11502 if (next < 0) { break } 11503 textEnd += next; 11504 rest = html.slice(textEnd); 11505 } 11506 text = html.substring(0, textEnd); 11507 } 11508 11509 if (textEnd < 0) { 11510 text = html; 11511 } 11512 11513 if (text) { 11514 advance(text.length); 11515 } 11516 11517 if (options.chars && text) { 11518 options.chars(text, index - text.length, index); 11519 } 11520 } else { 11521 var endTagLength = 0; 11522 var stackedTag = lastTag.toLowerCase(); 11523 var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i')); 11524 var rest$1 = html.replace(reStackedTag, function (all, text, endTag) { 11525 endTagLength = endTag.length; 11526 if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') { 11527 text = text 11528 .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298 11529 .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1'); 11530 } 11531 if (shouldIgnoreFirstNewline(stackedTag, text)) { 11532 text = text.slice(1); 11533 } 11534 if (options.chars) { 11535 options.chars(text); 11536 } 11537 return '' 11538 }); 11539 index += html.length - rest$1.length; 11540 html = rest$1; 11541 parseEndTag(stackedTag, index - endTagLength, index); 11542 } 11543 11544 if (html === last) { 11545 options.chars && options.chars(html); 11546 if (!stack.length && options.warn) { 11547 options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length }); 11548 } 11549 break 11550 } 11551 } 11552 11553 // Clean up any remaining tags 11554 parseEndTag(); 11555 11556 function advance (n) { 11557 index += n; 11558 html = html.substring(n); 11559 } 11560 11561 function parseStartTag () { 11562 var start = html.match(startTagOpen); 11563 if (start) { 11564 var match = { 11565 tagName: start[1], 11566 attrs: [], 11567 start: index 11568 }; 11569 advance(start[0].length); 11570 var end, attr; 11571 while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) { 11572 attr.start = index; 11573 advance(attr[0].length); 11574 attr.end = index; 11575 match.attrs.push(attr); 11576 } 11577 if (end) { 11578 match.unarySlash = end[1]; 11579 advance(end[0].length); 11580 match.end = index; 11581 return match 11582 } 11583 } 11584 } 11585 11586 function handleStartTag (match) { 11587 var tagName = match.tagName; 11588 var unarySlash = match.unarySlash; 11589 11590 if (expectHTML) { 11591 if (lastTag === 'p' && isNonPhrasingTag(tagName)) { 11592 parseEndTag(lastTag); 11593 } 11594 if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) { 11595 parseEndTag(tagName); 11596 } 11597 } 11598 11599 var unary = isUnaryTag$$1(tagName) || !!unarySlash; 11600 11601 var l = match.attrs.length; 11602 var attrs = new Array(l); 11603 for (var i = 0; i < l; i++) { 11604 var args = match.attrs[i]; 11605 var value = args[3] || args[4] || args[5] || ''; 11606 var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' 11607 ? options.shouldDecodeNewlinesForHref 11608 : options.shouldDecodeNewlines; 11609 attrs[i] = { 11610 name: args[1], 11611 value: decodeAttr(value, shouldDecodeNewlines) 11612 }; 11613 if (options.outputSourceRange) { 11614 attrs[i].start = args.start + args[0].match(/^\s*/).length; 11615 attrs[i].end = args.end; 11616 } 11617 } 11618 11619 if (!unary) { 11620 stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end }); 11621 lastTag = tagName; 11622 } 11623 11624 if (options.start) { 11625 options.start(tagName, attrs, unary, match.start, match.end); 11626 } 11627 } 11628 11629 function parseEndTag (tagName, start, end) { 11630 var pos, lowerCasedTagName; 11631 if (start == null) { start = index; } 11632 if (end == null) { end = index; } 11633 11634 // Find the closest opened tag of the same type 11635 if (tagName) { 11636 lowerCasedTagName = tagName.toLowerCase(); 11637 for (pos = stack.length - 1; pos >= 0; pos--) { 11638 if (stack[pos].lowerCasedTag === lowerCasedTagName) { 11639 break 11640 } 11641 } 11642 } else { 11643 // If no tag name is provided, clean shop 11644 pos = 0; 11645 } 11646 11647 if (pos >= 0) { 11648 // Close all the open elements, up the stack 11649 for (var i = stack.length - 1; i >= pos; i--) { 11650 if (i > pos || !tagName && 11651 options.warn 11652 ) { 11653 options.warn( 11654 ("tag <" + (stack[i].tag) + "> has no matching end tag."), 11655 { start: stack[i].start, end: stack[i].end } 11656 ); 11657 } 11658 if (options.end) { 11659 options.end(stack[i].tag, start, end); 11660 } 11661 } 11662 11663 // Remove the open elements from the stack 11664 stack.length = pos; 11665 lastTag = pos && stack[pos - 1].tag; 11666 } else if (lowerCasedTagName === 'br') { 11667 if (options.start) { 11668 options.start(tagName, [], true, start, end); 11669 } 11670 } else if (lowerCasedTagName === 'p') { 11671 if (options.start) { 11672 options.start(tagName, [], false, start, end); 11673 } 11674 if (options.end) { 11675 options.end(tagName, start, end); 11676 } 11677 } 11678 } 11679} 11680 11681/* */ 11682 11683var onRE = /^@|^v-on:/; 11684var dirRE = /^v-|^@|^:|^#/; 11685var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/; 11686var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; 11687var stripParensRE = /^\(|\)$/g; 11688var dynamicArgRE = /^\[.*\]$/; 11689 11690var argRE = /:(.*)$/; 11691var bindRE = /^:|^\.|^v-bind:/; 11692var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g; 11693 11694var slotRE = /^v-slot(:|$)|^#/; 11695 11696var lineBreakRE = /[\r\n]/; 11697var whitespaceRE$1 = /[ \f\t\r\n]+/g; 11698 11699var invalidAttributeRE = /[\s"'<>\/=]/; 11700 11701var decodeHTMLCached = cached(he.decode); 11702 11703var emptySlotScopeToken = "_empty_"; 11704 11705// configurable state 11706var warn$2; 11707var delimiters; 11708var transforms; 11709var preTransforms; 11710var postTransforms; 11711var platformIsPreTag; 11712var platformMustUseProp; 11713var platformGetTagNamespace; 11714var maybeComponent; 11715 11716function createASTElement ( 11717 tag, 11718 attrs, 11719 parent 11720) { 11721 return { 11722 type: 1, 11723 tag: tag, 11724 attrsList: attrs, 11725 attrsMap: makeAttrsMap(attrs), 11726 rawAttrsMap: {}, 11727 parent: parent, 11728 children: [] 11729 } 11730} 11731 11732/** 11733 * Convert HTML string to AST. 11734 */ 11735function parse ( 11736 template, 11737 options 11738) { 11739 warn$2 = options.warn || baseWarn; 11740 11741 platformIsPreTag = options.isPreTag || no; 11742 platformMustUseProp = options.mustUseProp || no; 11743 platformGetTagNamespace = options.getTagNamespace || no; 11744 var isReservedTag = options.isReservedTag || no; 11745 maybeComponent = function (el) { return !!( 11746 el.component || 11747 el.attrsMap[':is'] || 11748 el.attrsMap['v-bind:is'] || 11749 !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)) 11750 ); }; 11751 transforms = pluckModuleFunction(options.modules, 'transformNode'); 11752 preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); 11753 postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); 11754 11755 delimiters = options.delimiters; 11756 11757 var stack = []; 11758 var preserveWhitespace = options.preserveWhitespace !== false; 11759 var whitespaceOption = options.whitespace; 11760 var root; 11761 var currentParent; 11762 var inVPre = false; 11763 var inPre = false; 11764 var warned = false; 11765 11766 function warnOnce (msg, range) { 11767 if (!warned) { 11768 warned = true; 11769 warn$2(msg, range); 11770 } 11771 } 11772 11773 function closeElement (element) { 11774 trimEndingWhitespace(element); 11775 if (!inVPre && !element.processed) { 11776 element = processElement(element, options); 11777 } 11778 // tree management 11779 if (!stack.length && element !== root) { 11780 // allow root elements with v-if, v-else-if and v-else 11781 if (root.if && (element.elseif || element.else)) { 11782 { 11783 checkRootConstraints(element); 11784 } 11785 addIfCondition(root, { 11786 exp: element.elseif, 11787 block: element 11788 }); 11789 } else { 11790 warnOnce( 11791 "Component template should contain exactly one root element. " + 11792 "If you are using v-if on multiple elements, " + 11793 "use v-else-if to chain them instead.", 11794 { start: element.start } 11795 ); 11796 } 11797 } 11798 if (currentParent && !element.forbidden) { 11799 if (element.elseif || element.else) { 11800 processIfConditions(element, currentParent); 11801 } else { 11802 if (element.slotScope) { 11803 // scoped slot 11804 // keep it in the children list so that v-else(-if) conditions can 11805 // find it as the prev node. 11806 var name = element.slotTarget || '"default"' 11807 ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element; 11808 } 11809 currentParent.children.push(element); 11810 element.parent = currentParent; 11811 } 11812 } 11813 11814 // final children cleanup 11815 // filter out scoped slots 11816 element.children = element.children.filter(function (c) { return !(c).slotScope; }); 11817 // remove trailing whitespace node again 11818 trimEndingWhitespace(element); 11819 11820 // check pre state 11821 if (element.pre) { 11822 inVPre = false; 11823 } 11824 if (platformIsPreTag(element.tag)) { 11825 inPre = false; 11826 } 11827 // apply post-transforms 11828 for (var i = 0; i < postTransforms.length; i++) { 11829 postTransforms[i](element, options); 11830 } 11831 } 11832 11833 function trimEndingWhitespace (el) { 11834 // remove trailing whitespace node 11835 if (!inPre) { 11836 var lastNode; 11837 while ( 11838 (lastNode = el.children[el.children.length - 1]) && 11839 lastNode.type === 3 && 11840 lastNode.text === ' ' 11841 ) { 11842 el.children.pop(); 11843 } 11844 } 11845 } 11846 11847 function checkRootConstraints (el) { 11848 if (el.tag === 'slot' || el.tag === 'template') { 11849 warnOnce( 11850 "Cannot use <" + (el.tag) + "> as component root element because it may " + 11851 'contain multiple nodes.', 11852 { start: el.start } 11853 ); 11854 } 11855 if (el.attrsMap.hasOwnProperty('v-for')) { 11856 warnOnce( 11857 'Cannot use v-for on stateful component root element because ' + 11858 'it renders multiple elements.', 11859 el.rawAttrsMap['v-for'] 11860 ); 11861 } 11862 } 11863 11864 parseHTML(template, { 11865 warn: warn$2, 11866 expectHTML: options.expectHTML, 11867 isUnaryTag: options.isUnaryTag, 11868 canBeLeftOpenTag: options.canBeLeftOpenTag, 11869 shouldDecodeNewlines: options.shouldDecodeNewlines, 11870 shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, 11871 shouldKeepComment: options.comments, 11872 outputSourceRange: options.outputSourceRange, 11873 start: function start (tag, attrs, unary, start$1, end) { 11874 // check namespace. 11875 // inherit parent ns if there is one 11876 var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag); 11877 11878 // handle IE svg bug 11879 /* istanbul ignore if */ 11880 if (isIE && ns === 'svg') { 11881 attrs = guardIESVGBug(attrs); 11882 } 11883 11884 var element = createASTElement(tag, attrs, currentParent); 11885 if (ns) { 11886 element.ns = ns; 11887 } 11888 11889 { 11890 if (options.outputSourceRange) { 11891 element.start = start$1; 11892 element.end = end; 11893 element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) { 11894 cumulated[attr.name] = attr; 11895 return cumulated 11896 }, {}); 11897 } 11898 attrs.forEach(function (attr) { 11899 if (invalidAttributeRE.test(attr.name)) { 11900 warn$2( 11901 "Invalid dynamic argument expression: attribute names cannot contain " + 11902 "spaces, quotes, <, >, / or =.", 11903 { 11904 start: attr.start + attr.name.indexOf("["), 11905 end: attr.start + attr.name.length 11906 } 11907 ); 11908 } 11909 }); 11910 } 11911 11912 if (isForbiddenTag(element) && !isServerRendering()) { 11913 element.forbidden = true; 11914 warn$2( 11915 'Templates should only be responsible for mapping the state to the ' + 11916 'UI. Avoid placing tags with side-effects in your templates, such as ' + 11917 "<" + tag + ">" + ', as they will not be parsed.', 11918 { start: element.start } 11919 ); 11920 } 11921 11922 // apply pre-transforms 11923 for (var i = 0; i < preTransforms.length; i++) { 11924 element = preTransforms[i](element, options) || element; 11925 } 11926 11927 if (!inVPre) { 11928 processPre(element); 11929 if (element.pre) { 11930 inVPre = true; 11931 } 11932 } 11933 if (platformIsPreTag(element.tag)) { 11934 inPre = true; 11935 } 11936 if (inVPre) { 11937 processRawAttrs(element); 11938 } else if (!element.processed) { 11939 // structural directives 11940 processFor(element); 11941 processIf(element); 11942 processOnce(element); 11943 } 11944 11945 if (!root) { 11946 root = element; 11947 { 11948 checkRootConstraints(root); 11949 } 11950 } 11951 11952 if (!unary) { 11953 currentParent = element; 11954 stack.push(element); 11955 } else { 11956 closeElement(element); 11957 } 11958 }, 11959 11960 end: function end (tag, start, end$1) { 11961 var element = stack[stack.length - 1]; 11962 // pop stack 11963 stack.length -= 1; 11964 currentParent = stack[stack.length - 1]; 11965 if (options.outputSourceRange) { 11966 element.end = end$1; 11967 } 11968 closeElement(element); 11969 }, 11970 11971 chars: function chars (text, start, end) { 11972 if (!currentParent) { 11973 { 11974 if (text === template) { 11975 warnOnce( 11976 'Component template requires a root element, rather than just text.', 11977 { start: start } 11978 ); 11979 } else if ((text = text.trim())) { 11980 warnOnce( 11981 ("text \"" + text + "\" outside root element will be ignored."), 11982 { start: start } 11983 ); 11984 } 11985 } 11986 return 11987 } 11988 // IE textarea placeholder bug 11989 /* istanbul ignore if */ 11990 if (isIE && 11991 currentParent.tag === 'textarea' && 11992 currentParent.attrsMap.placeholder === text 11993 ) { 11994 return 11995 } 11996 var children = currentParent.children; 11997 if (inPre || text.trim()) { 11998 text = isTextTag(currentParent) ? text : decodeHTMLCached(text); 11999 } else if (!children.length) { 12000 // remove the whitespace-only node right after an opening tag 12001 text = ''; 12002 } else if (whitespaceOption) { 12003 if (whitespaceOption === 'condense') { 12004 // in condense mode, remove the whitespace node if it contains 12005 // line break, otherwise condense to a single space 12006 text = lineBreakRE.test(text) ? '' : ' '; 12007 } else { 12008 text = ' '; 12009 } 12010 } else { 12011 text = preserveWhitespace ? ' ' : ''; 12012 } 12013 if (text) { 12014 if (!inPre && whitespaceOption === 'condense') { 12015 // condense consecutive whitespaces into single space 12016 text = text.replace(whitespaceRE$1, ' '); 12017 } 12018 var res; 12019 var child; 12020 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) { 12021 child = { 12022 type: 2, 12023 expression: res.expression, 12024 tokens: res.tokens, 12025 text: text 12026 }; 12027 } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') { 12028 child = { 12029 type: 3, 12030 text: text 12031 }; 12032 } 12033 if (child) { 12034 if (options.outputSourceRange) { 12035 child.start = start; 12036 child.end = end; 12037 } 12038 children.push(child); 12039 } 12040 } 12041 }, 12042 comment: function comment (text, start, end) { 12043 // adding anything as a sibling to the root node is forbidden 12044 // comments should still be allowed, but ignored 12045 if (currentParent) { 12046 var child = { 12047 type: 3, 12048 text: text, 12049 isComment: true 12050 }; 12051 if (options.outputSourceRange) { 12052 child.start = start; 12053 child.end = end; 12054 } 12055 currentParent.children.push(child); 12056 } 12057 } 12058 }); 12059 return root 12060} 12061 12062function processPre (el) { 12063 if (getAndRemoveAttr(el, 'v-pre') != null) { 12064 el.pre = true; 12065 } 12066} 12067 12068function processRawAttrs (el) { 12069 var list = el.attrsList; 12070 var len = list.length; 12071 if (len) { 12072 var attrs = el.attrs = new Array(len); 12073 for (var i = 0; i < len; i++) { 12074 attrs[i] = { 12075 name: list[i].name, 12076 value: JSON.stringify(list[i].value) 12077 }; 12078 if (list[i].start != null) { 12079 attrs[i].start = list[i].start; 12080 attrs[i].end = list[i].end; 12081 } 12082 } 12083 } else if (!el.pre) { 12084 // non root node in pre blocks with no attributes 12085 el.plain = true; 12086 } 12087} 12088 12089function processElement ( 12090 element, 12091 options 12092) { 12093 processKey(element); 12094 12095 // determine whether this is a plain element after 12096 // removing structural attributes 12097 element.plain = ( 12098 !element.key && 12099 !element.scopedSlots && 12100 !element.attrsList.length 12101 ); 12102 12103 processRef(element); 12104 processSlotContent(element); 12105 processSlotOutlet(element); 12106 processComponent(element); 12107 for (var i = 0; i < transforms.length; i++) { 12108 element = transforms[i](element, options) || element; 12109 } 12110 processAttrs(element); 12111 return element 12112} 12113 12114function processKey (el) { 12115 var exp = getBindingAttr(el, 'key'); 12116 if (exp) { 12117 { 12118 if (el.tag === 'template') { 12119 warn$2( 12120 "<template> cannot be keyed. Place the key on real elements instead.", 12121 getRawBindingAttr(el, 'key') 12122 ); 12123 } 12124 if (el.for) { 12125 var iterator = el.iterator2 || el.iterator1; 12126 var parent = el.parent; 12127 if (iterator && iterator === exp && parent && parent.tag === 'transition-group') { 12128 warn$2( 12129 "Do not use v-for index as key on <transition-group> children, " + 12130 "this is the same as not using keys.", 12131 getRawBindingAttr(el, 'key'), 12132 true /* tip */ 12133 ); 12134 } 12135 } 12136 } 12137 el.key = exp; 12138 } 12139} 12140 12141function processRef (el) { 12142 var ref = getBindingAttr(el, 'ref'); 12143 if (ref) { 12144 el.ref = ref; 12145 el.refInFor = checkInFor(el); 12146 } 12147} 12148 12149function processFor (el) { 12150 var exp; 12151 if ((exp = getAndRemoveAttr(el, 'v-for'))) { 12152 var res = parseFor(exp); 12153 if (res) { 12154 extend(el, res); 12155 } else { 12156 warn$2( 12157 ("Invalid v-for expression: " + exp), 12158 el.rawAttrsMap['v-for'] 12159 ); 12160 } 12161 } 12162} 12163 12164 12165 12166function parseFor (exp) { 12167 var inMatch = exp.match(forAliasRE); 12168 if (!inMatch) { return } 12169 var res = {}; 12170 res.for = inMatch[2].trim(); 12171 var alias = inMatch[1].trim().replace(stripParensRE, ''); 12172 var iteratorMatch = alias.match(forIteratorRE); 12173 if (iteratorMatch) { 12174 res.alias = alias.replace(forIteratorRE, '').trim(); 12175 res.iterator1 = iteratorMatch[1].trim(); 12176 if (iteratorMatch[2]) { 12177 res.iterator2 = iteratorMatch[2].trim(); 12178 } 12179 } else { 12180 res.alias = alias; 12181 } 12182 return res 12183} 12184 12185function processIf (el) { 12186 var exp = getAndRemoveAttr(el, 'v-if'); 12187 if (exp) { 12188 el.if = exp; 12189 addIfCondition(el, { 12190 exp: exp, 12191 block: el 12192 }); 12193 } else { 12194 if (getAndRemoveAttr(el, 'v-else') != null) { 12195 el.else = true; 12196 } 12197 var elseif = getAndRemoveAttr(el, 'v-else-if'); 12198 if (elseif) { 12199 el.elseif = elseif; 12200 } 12201 } 12202} 12203 12204function processIfConditions (el, parent) { 12205 var prev = findPrevElement(parent.children); 12206 if (prev && prev.if) { 12207 addIfCondition(prev, { 12208 exp: el.elseif, 12209 block: el 12210 }); 12211 } else { 12212 warn$2( 12213 "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " + 12214 "used on element <" + (el.tag) + "> without corresponding v-if.", 12215 el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else'] 12216 ); 12217 } 12218} 12219 12220function findPrevElement (children) { 12221 var i = children.length; 12222 while (i--) { 12223 if (children[i].type === 1) { 12224 return children[i] 12225 } else { 12226 if (children[i].text !== ' ') { 12227 warn$2( 12228 "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " + 12229 "will be ignored.", 12230 children[i] 12231 ); 12232 } 12233 children.pop(); 12234 } 12235 } 12236} 12237 12238function addIfCondition (el, condition) { 12239 if (!el.ifConditions) { 12240 el.ifConditions = []; 12241 } 12242 el.ifConditions.push(condition); 12243} 12244 12245function processOnce (el) { 12246 var once$$1 = getAndRemoveAttr(el, 'v-once'); 12247 if (once$$1 != null) { 12248 el.once = true; 12249 } 12250} 12251 12252// handle content being passed to a component as slot, 12253// e.g. <template slot="xxx">, <div slot-scope="xxx"> 12254function processSlotContent (el) { 12255 var slotScope; 12256 if (el.tag === 'template') { 12257 slotScope = getAndRemoveAttr(el, 'scope'); 12258 /* istanbul ignore if */ 12259 if (slotScope) { 12260 warn$2( 12261 "the \"scope\" attribute for scoped slots have been deprecated and " + 12262 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " + 12263 "can also be used on plain elements in addition to <template> to " + 12264 "denote scoped slots.", 12265 el.rawAttrsMap['scope'], 12266 true 12267 ); 12268 } 12269 el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope'); 12270 } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { 12271 /* istanbul ignore if */ 12272 if (el.attrsMap['v-for']) { 12273 warn$2( 12274 "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " + 12275 "(v-for takes higher priority). Use a wrapper <template> for the " + 12276 "scoped slot to make it clearer.", 12277 el.rawAttrsMap['slot-scope'], 12278 true 12279 ); 12280 } 12281 el.slotScope = slotScope; 12282 } 12283 12284 // slot="xxx" 12285 var slotTarget = getBindingAttr(el, 'slot'); 12286 if (slotTarget) { 12287 el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; 12288 el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']); 12289 // preserve slot as an attribute for native shadow DOM compat 12290 // only for non-scoped slots. 12291 if (el.tag !== 'template' && !el.slotScope) { 12292 addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot')); 12293 } 12294 } 12295 12296 // 2.6 v-slot syntax 12297 { 12298 if (el.tag === 'template') { 12299 // v-slot on <template> 12300 var slotBinding = getAndRemoveAttrByRegex(el, slotRE); 12301 if (slotBinding) { 12302 { 12303 if (el.slotTarget || el.slotScope) { 12304 warn$2( 12305 "Unexpected mixed usage of different slot syntaxes.", 12306 el 12307 ); 12308 } 12309 if (el.parent && !maybeComponent(el.parent)) { 12310 warn$2( 12311 "<template v-slot> can only appear at the root level inside " + 12312 "the receiving component", 12313 el 12314 ); 12315 } 12316 } 12317 var ref = getSlotName(slotBinding); 12318 var name = ref.name; 12319 var dynamic = ref.dynamic; 12320 el.slotTarget = name; 12321 el.slotTargetDynamic = dynamic; 12322 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf 12323 } 12324 } else { 12325 // v-slot on component, denotes default slot 12326 var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE); 12327 if (slotBinding$1) { 12328 { 12329 if (!maybeComponent(el)) { 12330 warn$2( 12331 "v-slot can only be used on components or <template>.", 12332 slotBinding$1 12333 ); 12334 } 12335 if (el.slotScope || el.slotTarget) { 12336 warn$2( 12337 "Unexpected mixed usage of different slot syntaxes.", 12338 el 12339 ); 12340 } 12341 if (el.scopedSlots) { 12342 warn$2( 12343 "To avoid scope ambiguity, the default slot should also use " + 12344 "<template> syntax when there are other named slots.", 12345 slotBinding$1 12346 ); 12347 } 12348 } 12349 // add the component's children to its default slot 12350 var slots = el.scopedSlots || (el.scopedSlots = {}); 12351 var ref$1 = getSlotName(slotBinding$1); 12352 var name$1 = ref$1.name; 12353 var dynamic$1 = ref$1.dynamic; 12354 var slotContainer = slots[name$1] = createASTElement('template', [], el); 12355 slotContainer.slotTarget = name$1; 12356 slotContainer.slotTargetDynamic = dynamic$1; 12357 slotContainer.children = el.children.filter(function (c) { 12358 if (!c.slotScope) { 12359 c.parent = slotContainer; 12360 return true 12361 } 12362 }); 12363 slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken; 12364 // remove children as they are returned from scopedSlots now 12365 el.children = []; 12366 // mark el non-plain so data gets generated 12367 el.plain = false; 12368 } 12369 } 12370 } 12371} 12372 12373function getSlotName (binding) { 12374 var name = binding.name.replace(slotRE, ''); 12375 if (!name) { 12376 if (binding.name[0] !== '#') { 12377 name = 'default'; 12378 } else { 12379 warn$2( 12380 "v-slot shorthand syntax requires a slot name.", 12381 binding 12382 ); 12383 } 12384 } 12385 return dynamicArgRE.test(name) 12386 // dynamic [name] 12387 ? { name: name.slice(1, -1), dynamic: true } 12388 // static name 12389 : { name: ("\"" + name + "\""), dynamic: false } 12390} 12391 12392// handle <slot/> outlets 12393function processSlotOutlet (el) { 12394 if (el.tag === 'slot') { 12395 el.slotName = getBindingAttr(el, 'name'); 12396 if (el.key) { 12397 warn$2( 12398 "`key` does not work on <slot> because slots are abstract outlets " + 12399 "and can possibly expand into multiple elements. " + 12400 "Use the key on a wrapping element instead.", 12401 getRawBindingAttr(el, 'key') 12402 ); 12403 } 12404 } 12405} 12406 12407function processComponent (el) { 12408 var binding; 12409 if ((binding = getBindingAttr(el, 'is'))) { 12410 el.component = binding; 12411 } 12412 if (getAndRemoveAttr(el, 'inline-template') != null) { 12413 el.inlineTemplate = true; 12414 } 12415} 12416 12417function processAttrs (el) { 12418 var list = el.attrsList; 12419 var i, l, name, rawName, value, modifiers, syncGen, isDynamic; 12420 for (i = 0, l = list.length; i < l; i++) { 12421 name = rawName = list[i].name; 12422 value = list[i].value; 12423 if (dirRE.test(name)) { 12424 // mark element as dynamic 12425 el.hasBindings = true; 12426 // modifiers 12427 modifiers = parseModifiers(name.replace(dirRE, '')); 12428 // support .foo shorthand syntax for the .prop modifier 12429 if (modifiers) { 12430 name = name.replace(modifierRE, ''); 12431 } 12432 if (bindRE.test(name)) { // v-bind 12433 name = name.replace(bindRE, ''); 12434 value = parseFilters(value); 12435 isDynamic = dynamicArgRE.test(name); 12436 if (isDynamic) { 12437 name = name.slice(1, -1); 12438 } 12439 if ( 12440 value.trim().length === 0 12441 ) { 12442 warn$2( 12443 ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"") 12444 ); 12445 } 12446 if (modifiers) { 12447 if (modifiers.prop && !isDynamic) { 12448 name = camelize(name); 12449 if (name === 'innerHtml') { name = 'innerHTML'; } 12450 } 12451 if (modifiers.camel && !isDynamic) { 12452 name = camelize(name); 12453 } 12454 if (modifiers.sync) { 12455 syncGen = genAssignmentCode(value, "$event"); 12456 if (!isDynamic) { 12457 addHandler( 12458 el, 12459 ("update:" + (camelize(name))), 12460 syncGen, 12461 null, 12462 false, 12463 warn$2, 12464 list[i] 12465 ); 12466 if (hyphenate(name) !== camelize(name)) { 12467 addHandler( 12468 el, 12469 ("update:" + (hyphenate(name))), 12470 syncGen, 12471 null, 12472 false, 12473 warn$2, 12474 list[i] 12475 ); 12476 } 12477 } else { 12478 // handler w/ dynamic event name 12479 addHandler( 12480 el, 12481 ("\"update:\"+(" + name + ")"), 12482 syncGen, 12483 null, 12484 false, 12485 warn$2, 12486 list[i], 12487 true // dynamic 12488 ); 12489 } 12490 } 12491 } 12492 if ((modifiers && modifiers.prop) || ( 12493 !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name) 12494 )) { 12495 addProp(el, name, value, list[i], isDynamic); 12496 } else { 12497 addAttr(el, name, value, list[i], isDynamic); 12498 } 12499 } else if (onRE.test(name)) { // v-on 12500 name = name.replace(onRE, ''); 12501 isDynamic = dynamicArgRE.test(name); 12502 if (isDynamic) { 12503 name = name.slice(1, -1); 12504 } 12505 addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic); 12506 } else { // normal directives 12507 name = name.replace(dirRE, ''); 12508 // parse arg 12509 var argMatch = name.match(argRE); 12510 var arg = argMatch && argMatch[1]; 12511 isDynamic = false; 12512 if (arg) { 12513 name = name.slice(0, -(arg.length + 1)); 12514 if (dynamicArgRE.test(arg)) { 12515 arg = arg.slice(1, -1); 12516 isDynamic = true; 12517 } 12518 } 12519 addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]); 12520 if (name === 'model') { 12521 checkForAliasModel(el, value); 12522 } 12523 } 12524 } else { 12525 // literal attribute 12526 { 12527 var res = parseText(value, delimiters); 12528 if (res) { 12529 warn$2( 12530 name + "=\"" + value + "\": " + 12531 'Interpolation inside attributes has been removed. ' + 12532 'Use v-bind or the colon shorthand instead. For example, ' + 12533 'instead of <div id="{{ val }}">, use <div :id="val">.', 12534 list[i] 12535 ); 12536 } 12537 } 12538 addAttr(el, name, JSON.stringify(value), list[i]); 12539 // #6887 firefox doesn't update muted state if set via attribute 12540 // even immediately after element creation 12541 if (!el.component && 12542 name === 'muted' && 12543 platformMustUseProp(el.tag, el.attrsMap.type, name)) { 12544 addProp(el, name, 'true', list[i]); 12545 } 12546 } 12547 } 12548} 12549 12550function checkInFor (el) { 12551 var parent = el; 12552 while (parent) { 12553 if (parent.for !== undefined) { 12554 return true 12555 } 12556 parent = parent.parent; 12557 } 12558 return false 12559} 12560 12561function parseModifiers (name) { 12562 var match = name.match(modifierRE); 12563 if (match) { 12564 var ret = {}; 12565 match.forEach(function (m) { ret[m.slice(1)] = true; }); 12566 return ret 12567 } 12568} 12569 12570function makeAttrsMap (attrs) { 12571 var map = {}; 12572 for (var i = 0, l = attrs.length; i < l; i++) { 12573 if ( 12574 map[attrs[i].name] && !isIE && !isEdge 12575 ) { 12576 warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]); 12577 } 12578 map[attrs[i].name] = attrs[i].value; 12579 } 12580 return map 12581} 12582 12583// for script (e.g. type="x/template") or style, do not decode content 12584function isTextTag (el) { 12585 return el.tag === 'script' || el.tag === 'style' 12586} 12587 12588function isForbiddenTag (el) { 12589 return ( 12590 el.tag === 'style' || 12591 (el.tag === 'script' && ( 12592 !el.attrsMap.type || 12593 el.attrsMap.type === 'text/javascript' 12594 )) 12595 ) 12596} 12597 12598var ieNSBug = /^xmlns:NS\d+/; 12599var ieNSPrefix = /^NS\d+:/; 12600 12601/* istanbul ignore next */ 12602function guardIESVGBug (attrs) { 12603 var res = []; 12604 for (var i = 0; i < attrs.length; i++) { 12605 var attr = attrs[i]; 12606 if (!ieNSBug.test(attr.name)) { 12607 attr.name = attr.name.replace(ieNSPrefix, ''); 12608 res.push(attr); 12609 } 12610 } 12611 return res 12612} 12613 12614function checkForAliasModel (el, value) { 12615 var _el = el; 12616 while (_el) { 12617 if (_el.for && _el.alias === value) { 12618 warn$2( 12619 "<" + (el.tag) + " v-model=\"" + value + "\">: " + 12620 "You are binding v-model directly to a v-for iteration alias. " + 12621 "This will not be able to modify the v-for source array because " + 12622 "writing to the alias is like modifying a function local variable. " + 12623 "Consider using an array of objects and use v-model on an object property instead.", 12624 el.rawAttrsMap['v-model'] 12625 ); 12626 } 12627 _el = _el.parent; 12628 } 12629} 12630 12631/* */ 12632 12633function preTransformNode (el, options) { 12634 if (el.tag === 'input') { 12635 var map = el.attrsMap; 12636 if (!map['v-model']) { 12637 return 12638 } 12639 12640 var typeBinding; 12641 if (map[':type'] || map['v-bind:type']) { 12642 typeBinding = getBindingAttr(el, 'type'); 12643 } 12644 if (!map.type && !typeBinding && map['v-bind']) { 12645 typeBinding = "(" + (map['v-bind']) + ").type"; 12646 } 12647 12648 if (typeBinding) { 12649 var ifCondition = getAndRemoveAttr(el, 'v-if', true); 12650 var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : ""; 12651 var hasElse = getAndRemoveAttr(el, 'v-else', true) != null; 12652 var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); 12653 // 1. checkbox 12654 var branch0 = cloneASTElement(el); 12655 // process for on the main node 12656 processFor(branch0); 12657 addRawAttr(branch0, 'type', 'checkbox'); 12658 processElement(branch0, options); 12659 branch0.processed = true; // prevent it from double-processed 12660 branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra; 12661 addIfCondition(branch0, { 12662 exp: branch0.if, 12663 block: branch0 12664 }); 12665 // 2. add radio else-if condition 12666 var branch1 = cloneASTElement(el); 12667 getAndRemoveAttr(branch1, 'v-for', true); 12668 addRawAttr(branch1, 'type', 'radio'); 12669 processElement(branch1, options); 12670 addIfCondition(branch0, { 12671 exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra, 12672 block: branch1 12673 }); 12674 // 3. other 12675 var branch2 = cloneASTElement(el); 12676 getAndRemoveAttr(branch2, 'v-for', true); 12677 addRawAttr(branch2, ':type', typeBinding); 12678 processElement(branch2, options); 12679 addIfCondition(branch0, { 12680 exp: ifCondition, 12681 block: branch2 12682 }); 12683 12684 if (hasElse) { 12685 branch0.else = true; 12686 } else if (elseIfCondition) { 12687 branch0.elseif = elseIfCondition; 12688 } 12689 12690 return branch0 12691 } 12692 } 12693} 12694 12695function cloneASTElement (el) { 12696 return createASTElement(el.tag, el.attrsList.slice(), el.parent) 12697} 12698 12699var model$1 = { 12700 preTransformNode: preTransformNode 12701}; 12702 12703var modules$1 = [ 12704 klass$1, 12705 style$1, 12706 model$1 12707]; 12708 12709/* */ 12710 12711function text (el, dir) { 12712 if (dir.value) { 12713 addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir); 12714 } 12715} 12716 12717/* */ 12718 12719function html (el, dir) { 12720 if (dir.value) { 12721 addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir); 12722 } 12723} 12724 12725var directives$1 = { 12726 model: model, 12727 text: text, 12728 html: html 12729}; 12730 12731/* */ 12732 12733var baseOptions = { 12734 expectHTML: true, 12735 modules: modules$1, 12736 directives: directives$1, 12737 isPreTag: isPreTag, 12738 isUnaryTag: isUnaryTag, 12739 mustUseProp: mustUseProp, 12740 canBeLeftOpenTag: canBeLeftOpenTag, 12741 isReservedTag: isReservedTag, 12742 getTagNamespace: getTagNamespace, 12743 staticKeys: genStaticKeys(modules$1) 12744}; 12745 12746/* */ 12747 12748var isStaticKey; 12749var isPlatformReservedTag; 12750 12751var genStaticKeysCached = cached(genStaticKeys$1); 12752 12753/** 12754 * Goal of the optimizer: walk the generated template AST tree 12755 * and detect sub-trees that are purely static, i.e. parts of 12756 * the DOM that never needs to change. 12757 * 12758 * Once we detect these sub-trees, we can: 12759 * 12760 * 1. Hoist them into constants, so that we no longer need to 12761 * create fresh nodes for them on each re-render; 12762 * 2. Completely skip them in the patching process. 12763 */ 12764function optimize (root, options) { 12765 if (!root) { return } 12766 isStaticKey = genStaticKeysCached(options.staticKeys || ''); 12767 isPlatformReservedTag = options.isReservedTag || no; 12768 // first pass: mark all non-static nodes. 12769 markStatic$1(root); 12770 // second pass: mark static roots. 12771 markStaticRoots(root, false); 12772} 12773 12774function genStaticKeys$1 (keys) { 12775 return makeMap( 12776 'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' + 12777 (keys ? ',' + keys : '') 12778 ) 12779} 12780 12781function markStatic$1 (node) { 12782 node.static = isStatic(node); 12783 if (node.type === 1) { 12784 // do not make component slot content static. this avoids 12785 // 1. components not able to mutate slot nodes 12786 // 2. static slot content fails for hot-reloading 12787 if ( 12788 !isPlatformReservedTag(node.tag) && 12789 node.tag !== 'slot' && 12790 node.attrsMap['inline-template'] == null 12791 ) { 12792 return 12793 } 12794 for (var i = 0, l = node.children.length; i < l; i++) { 12795 var child = node.children[i]; 12796 markStatic$1(child); 12797 if (!child.static) { 12798 node.static = false; 12799 } 12800 } 12801 if (node.ifConditions) { 12802 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 12803 var block = node.ifConditions[i$1].block; 12804 markStatic$1(block); 12805 if (!block.static) { 12806 node.static = false; 12807 } 12808 } 12809 } 12810 } 12811} 12812 12813function markStaticRoots (node, isInFor) { 12814 if (node.type === 1) { 12815 if (node.static || node.once) { 12816 node.staticInFor = isInFor; 12817 } 12818 // For a node to qualify as a static root, it should have children that 12819 // are not just static text. Otherwise the cost of hoisting out will 12820 // outweigh the benefits and it's better off to just always render it fresh. 12821 if (node.static && node.children.length && !( 12822 node.children.length === 1 && 12823 node.children[0].type === 3 12824 )) { 12825 node.staticRoot = true; 12826 return 12827 } else { 12828 node.staticRoot = false; 12829 } 12830 if (node.children) { 12831 for (var i = 0, l = node.children.length; i < l; i++) { 12832 markStaticRoots(node.children[i], isInFor || !!node.for); 12833 } 12834 } 12835 if (node.ifConditions) { 12836 for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) { 12837 markStaticRoots(node.ifConditions[i$1].block, isInFor); 12838 } 12839 } 12840 } 12841} 12842 12843function isStatic (node) { 12844 if (node.type === 2) { // expression 12845 return false 12846 } 12847 if (node.type === 3) { // text 12848 return true 12849 } 12850 return !!(node.pre || ( 12851 !node.hasBindings && // no dynamic bindings 12852 !node.if && !node.for && // not v-if or v-for or v-else 12853 !isBuiltInTag(node.tag) && // not a built-in 12854 isPlatformReservedTag(node.tag) && // not a component 12855 !isDirectChildOfTemplateFor(node) && 12856 Object.keys(node).every(isStaticKey) 12857 )) 12858} 12859 12860function isDirectChildOfTemplateFor (node) { 12861 while (node.parent) { 12862 node = node.parent; 12863 if (node.tag !== 'template') { 12864 return false 12865 } 12866 if (node.for) { 12867 return true 12868 } 12869 } 12870 return false 12871} 12872 12873/* */ 12874 12875var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/; 12876var fnInvokeRE = /\([^)]*?\);*$/; 12877var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/; 12878 12879// KeyboardEvent.keyCode aliases 12880var keyCodes = { 12881 esc: 27, 12882 tab: 9, 12883 enter: 13, 12884 space: 32, 12885 up: 38, 12886 left: 37, 12887 right: 39, 12888 down: 40, 12889 'delete': [8, 46] 12890}; 12891 12892// KeyboardEvent.key aliases 12893var keyNames = { 12894 // #7880: IE11 and Edge use `Esc` for Escape key name. 12895 esc: ['Esc', 'Escape'], 12896 tab: 'Tab', 12897 enter: 'Enter', 12898 // #9112: IE11 uses `Spacebar` for Space key name. 12899 space: [' ', 'Spacebar'], 12900 // #7806: IE11 uses key names without `Arrow` prefix for arrow keys. 12901 up: ['Up', 'ArrowUp'], 12902 left: ['Left', 'ArrowLeft'], 12903 right: ['Right', 'ArrowRight'], 12904 down: ['Down', 'ArrowDown'], 12905 // #9112: IE11 uses `Del` for Delete key name. 12906 'delete': ['Backspace', 'Delete', 'Del'] 12907}; 12908 12909// #4868: modifiers that prevent the execution of the listener 12910// need to explicitly return null so that we can determine whether to remove 12911// the listener for .once 12912var genGuard = function (condition) { return ("if(" + condition + ")return null;"); }; 12913 12914var modifierCode = { 12915 stop: '$event.stopPropagation();', 12916 prevent: '$event.preventDefault();', 12917 self: genGuard("$event.target !== $event.currentTarget"), 12918 ctrl: genGuard("!$event.ctrlKey"), 12919 shift: genGuard("!$event.shiftKey"), 12920 alt: genGuard("!$event.altKey"), 12921 meta: genGuard("!$event.metaKey"), 12922 left: genGuard("'button' in $event && $event.button !== 0"), 12923 middle: genGuard("'button' in $event && $event.button !== 1"), 12924 right: genGuard("'button' in $event && $event.button !== 2") 12925}; 12926 12927function genHandlers ( 12928 events, 12929 isNative 12930) { 12931 var prefix = isNative ? 'nativeOn:' : 'on:'; 12932 var staticHandlers = ""; 12933 var dynamicHandlers = ""; 12934 for (var name in events) { 12935 var handlerCode = genHandler(events[name]); 12936 if (events[name] && events[name].dynamic) { 12937 dynamicHandlers += name + "," + handlerCode + ","; 12938 } else { 12939 staticHandlers += "\"" + name + "\":" + handlerCode + ","; 12940 } 12941 } 12942 staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}"; 12943 if (dynamicHandlers) { 12944 return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])" 12945 } else { 12946 return prefix + staticHandlers 12947 } 12948} 12949 12950function genHandler (handler) { 12951 if (!handler) { 12952 return 'function(){}' 12953 } 12954 12955 if (Array.isArray(handler)) { 12956 return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]") 12957 } 12958 12959 var isMethodPath = simplePathRE.test(handler.value); 12960 var isFunctionExpression = fnExpRE.test(handler.value); 12961 var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, '')); 12962 12963 if (!handler.modifiers) { 12964 if (isMethodPath || isFunctionExpression) { 12965 return handler.value 12966 } 12967 return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement 12968 } else { 12969 var code = ''; 12970 var genModifierCode = ''; 12971 var keys = []; 12972 for (var key in handler.modifiers) { 12973 if (modifierCode[key]) { 12974 genModifierCode += modifierCode[key]; 12975 // left/right 12976 if (keyCodes[key]) { 12977 keys.push(key); 12978 } 12979 } else if (key === 'exact') { 12980 var modifiers = (handler.modifiers); 12981 genModifierCode += genGuard( 12982 ['ctrl', 'shift', 'alt', 'meta'] 12983 .filter(function (keyModifier) { return !modifiers[keyModifier]; }) 12984 .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); }) 12985 .join('||') 12986 ); 12987 } else { 12988 keys.push(key); 12989 } 12990 } 12991 if (keys.length) { 12992 code += genKeyFilter(keys); 12993 } 12994 // Make sure modifiers like prevent and stop get executed after key filtering 12995 if (genModifierCode) { 12996 code += genModifierCode; 12997 } 12998 var handlerCode = isMethodPath 12999 ? ("return " + (handler.value) + ".apply(null, arguments)") 13000 : isFunctionExpression 13001 ? ("return (" + (handler.value) + ").apply(null, arguments)") 13002 : isFunctionInvocation 13003 ? ("return " + (handler.value)) 13004 : handler.value; 13005 return ("function($event){" + code + handlerCode + "}") 13006 } 13007} 13008 13009function genKeyFilter (keys) { 13010 return ( 13011 // make sure the key filters only apply to KeyboardEvents 13012 // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake 13013 // key events that do not have keyCode property... 13014 "if(!$event.type.indexOf('key')&&" + 13015 (keys.map(genFilterCode).join('&&')) + ")return null;" 13016 ) 13017} 13018 13019function genFilterCode (key) { 13020 var keyVal = parseInt(key, 10); 13021 if (keyVal) { 13022 return ("$event.keyCode!==" + keyVal) 13023 } 13024 var keyCode = keyCodes[key]; 13025 var keyName = keyNames[key]; 13026 return ( 13027 "_k($event.keyCode," + 13028 (JSON.stringify(key)) + "," + 13029 (JSON.stringify(keyCode)) + "," + 13030 "$event.key," + 13031 "" + (JSON.stringify(keyName)) + 13032 ")" 13033 ) 13034} 13035 13036/* */ 13037 13038function on (el, dir) { 13039 if (dir.modifiers) { 13040 warn("v-on without argument does not support modifiers."); 13041 } 13042 el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); }; 13043} 13044 13045/* */ 13046 13047function bind$1 (el, dir) { 13048 el.wrapData = function (code) { 13049 return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")") 13050 }; 13051} 13052 13053/* */ 13054 13055var baseDirectives = { 13056 on: on, 13057 bind: bind$1, 13058 cloak: noop 13059}; 13060 13061/* */ 13062 13063 13064 13065 13066 13067var CodegenState = function CodegenState (options) { 13068 this.options = options; 13069 this.warn = options.warn || baseWarn; 13070 this.transforms = pluckModuleFunction(options.modules, 'transformCode'); 13071 this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); 13072 this.directives = extend(extend({}, baseDirectives), options.directives); 13073 var isReservedTag = options.isReservedTag || no; 13074 this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); }; 13075 this.onceId = 0; 13076 this.staticRenderFns = []; 13077 this.pre = false; 13078}; 13079 13080 13081 13082function generate ( 13083 ast, 13084 options 13085) { 13086 var state = new CodegenState(options); 13087 // fix #11483, Root level <script> tags should not be rendered. 13088 var code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")'; 13089 return { 13090 render: ("with(this){return " + code + "}"), 13091 staticRenderFns: state.staticRenderFns 13092 } 13093} 13094 13095function genElement (el, state) { 13096 if (el.parent) { 13097 el.pre = el.pre || el.parent.pre; 13098 } 13099 13100 if (el.staticRoot && !el.staticProcessed) { 13101 return genStatic(el, state) 13102 } else if (el.once && !el.onceProcessed) { 13103 return genOnce(el, state) 13104 } else if (el.for && !el.forProcessed) { 13105 return genFor(el, state) 13106 } else if (el.if && !el.ifProcessed) { 13107 return genIf(el, state) 13108 } else if (el.tag === 'template' && !el.slotTarget && !state.pre) { 13109 return genChildren(el, state) || 'void 0' 13110 } else if (el.tag === 'slot') { 13111 return genSlot(el, state) 13112 } else { 13113 // component or element 13114 var code; 13115 if (el.component) { 13116 code = genComponent(el.component, el, state); 13117 } else { 13118 var data; 13119 if (!el.plain || (el.pre && state.maybeComponent(el))) { 13120 data = genData$2(el, state); 13121 } 13122 13123 var children = el.inlineTemplate ? null : genChildren(el, state, true); 13124 code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")"; 13125 } 13126 // module transforms 13127 for (var i = 0; i < state.transforms.length; i++) { 13128 code = state.transforms[i](el, code); 13129 } 13130 return code 13131 } 13132} 13133 13134// hoist static sub-trees out 13135function genStatic (el, state) { 13136 el.staticProcessed = true; 13137 // Some elements (templates) need to behave differently inside of a v-pre 13138 // node. All pre nodes are static roots, so we can use this as a location to 13139 // wrap a state change and reset it upon exiting the pre node. 13140 var originalPreState = state.pre; 13141 if (el.pre) { 13142 state.pre = el.pre; 13143 } 13144 state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}")); 13145 state.pre = originalPreState; 13146 return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")") 13147} 13148 13149// v-once 13150function genOnce (el, state) { 13151 el.onceProcessed = true; 13152 if (el.if && !el.ifProcessed) { 13153 return genIf(el, state) 13154 } else if (el.staticInFor) { 13155 var key = ''; 13156 var parent = el.parent; 13157 while (parent) { 13158 if (parent.for) { 13159 key = parent.key; 13160 break 13161 } 13162 parent = parent.parent; 13163 } 13164 if (!key) { 13165 state.warn( 13166 "v-once can only be used inside v-for that is keyed. ", 13167 el.rawAttrsMap['v-once'] 13168 ); 13169 return genElement(el, state) 13170 } 13171 return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")") 13172 } else { 13173 return genStatic(el, state) 13174 } 13175} 13176 13177function genIf ( 13178 el, 13179 state, 13180 altGen, 13181 altEmpty 13182) { 13183 el.ifProcessed = true; // avoid recursion 13184 return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty) 13185} 13186 13187function genIfConditions ( 13188 conditions, 13189 state, 13190 altGen, 13191 altEmpty 13192) { 13193 if (!conditions.length) { 13194 return altEmpty || '_e()' 13195 } 13196 13197 var condition = conditions.shift(); 13198 if (condition.exp) { 13199 return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty))) 13200 } else { 13201 return ("" + (genTernaryExp(condition.block))) 13202 } 13203 13204 // v-if with v-once should generate code like (a)?_m(0):_m(1) 13205 function genTernaryExp (el) { 13206 return altGen 13207 ? altGen(el, state) 13208 : el.once 13209 ? genOnce(el, state) 13210 : genElement(el, state) 13211 } 13212} 13213 13214function genFor ( 13215 el, 13216 state, 13217 altGen, 13218 altHelper 13219) { 13220 var exp = el.for; 13221 var alias = el.alias; 13222 var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : ''; 13223 var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : ''; 13224 13225 if (state.maybeComponent(el) && 13226 el.tag !== 'slot' && 13227 el.tag !== 'template' && 13228 !el.key 13229 ) { 13230 state.warn( 13231 "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " + 13232 "v-for should have explicit keys. " + 13233 "See https://vuejs.org/guide/list.html#key for more info.", 13234 el.rawAttrsMap['v-for'], 13235 true /* tip */ 13236 ); 13237 } 13238 13239 el.forProcessed = true; // avoid recursion 13240 return (altHelper || '_l') + "((" + exp + ")," + 13241 "function(" + alias + iterator1 + iterator2 + "){" + 13242 "return " + ((altGen || genElement)(el, state)) + 13243 '})' 13244} 13245 13246function genData$2 (el, state) { 13247 var data = '{'; 13248 13249 // directives first. 13250 // directives may mutate the el's other properties before they are generated. 13251 var dirs = genDirectives(el, state); 13252 if (dirs) { data += dirs + ','; } 13253 13254 // key 13255 if (el.key) { 13256 data += "key:" + (el.key) + ","; 13257 } 13258 // ref 13259 if (el.ref) { 13260 data += "ref:" + (el.ref) + ","; 13261 } 13262 if (el.refInFor) { 13263 data += "refInFor:true,"; 13264 } 13265 // pre 13266 if (el.pre) { 13267 data += "pre:true,"; 13268 } 13269 // record original tag name for components using "is" attribute 13270 if (el.component) { 13271 data += "tag:\"" + (el.tag) + "\","; 13272 } 13273 // module data generation functions 13274 for (var i = 0; i < state.dataGenFns.length; i++) { 13275 data += state.dataGenFns[i](el); 13276 } 13277 // attributes 13278 if (el.attrs) { 13279 data += "attrs:" + (genProps(el.attrs)) + ","; 13280 } 13281 // DOM props 13282 if (el.props) { 13283 data += "domProps:" + (genProps(el.props)) + ","; 13284 } 13285 // event handlers 13286 if (el.events) { 13287 data += (genHandlers(el.events, false)) + ","; 13288 } 13289 if (el.nativeEvents) { 13290 data += (genHandlers(el.nativeEvents, true)) + ","; 13291 } 13292 // slot target 13293 // only for non-scoped slots 13294 if (el.slotTarget && !el.slotScope) { 13295 data += "slot:" + (el.slotTarget) + ","; 13296 } 13297 // scoped slots 13298 if (el.scopedSlots) { 13299 data += (genScopedSlots(el, el.scopedSlots, state)) + ","; 13300 } 13301 // component v-model 13302 if (el.model) { 13303 data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},"; 13304 } 13305 // inline-template 13306 if (el.inlineTemplate) { 13307 var inlineTemplate = genInlineTemplate(el, state); 13308 if (inlineTemplate) { 13309 data += inlineTemplate + ","; 13310 } 13311 } 13312 data = data.replace(/,$/, '') + '}'; 13313 // v-bind dynamic argument wrap 13314 // v-bind with dynamic arguments must be applied using the same v-bind object 13315 // merge helper so that class/style/mustUseProp attrs are handled correctly. 13316 if (el.dynamicAttrs) { 13317 data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")"; 13318 } 13319 // v-bind data wrap 13320 if (el.wrapData) { 13321 data = el.wrapData(data); 13322 } 13323 // v-on data wrap 13324 if (el.wrapListeners) { 13325 data = el.wrapListeners(data); 13326 } 13327 return data 13328} 13329 13330function genDirectives (el, state) { 13331 var dirs = el.directives; 13332 if (!dirs) { return } 13333 var res = 'directives:['; 13334 var hasRuntime = false; 13335 var i, l, dir, needRuntime; 13336 for (i = 0, l = dirs.length; i < l; i++) { 13337 dir = dirs[i]; 13338 needRuntime = true; 13339 var gen = state.directives[dir.name]; 13340 if (gen) { 13341 // compile-time directive that manipulates AST. 13342 // returns true if it also needs a runtime counterpart. 13343 needRuntime = !!gen(el, dir, state.warn); 13344 } 13345 if (needRuntime) { 13346 hasRuntime = true; 13347 res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},"; 13348 } 13349 } 13350 if (hasRuntime) { 13351 return res.slice(0, -1) + ']' 13352 } 13353} 13354 13355function genInlineTemplate (el, state) { 13356 var ast = el.children[0]; 13357 if (el.children.length !== 1 || ast.type !== 1) { 13358 state.warn( 13359 'Inline-template components must have exactly one child element.', 13360 { start: el.start } 13361 ); 13362 } 13363 if (ast && ast.type === 1) { 13364 var inlineRenderFns = generate(ast, state.options); 13365 return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}") 13366 } 13367} 13368 13369function genScopedSlots ( 13370 el, 13371 slots, 13372 state 13373) { 13374 // by default scoped slots are considered "stable", this allows child 13375 // components with only scoped slots to skip forced updates from parent. 13376 // but in some cases we have to bail-out of this optimization 13377 // for example if the slot contains dynamic names, has v-if or v-for on them... 13378 var needsForceUpdate = el.for || Object.keys(slots).some(function (key) { 13379 var slot = slots[key]; 13380 return ( 13381 slot.slotTargetDynamic || 13382 slot.if || 13383 slot.for || 13384 containsSlotChild(slot) // is passing down slot from parent which may be dynamic 13385 ) 13386 }); 13387 13388 // #9534: if a component with scoped slots is inside a conditional branch, 13389 // it's possible for the same component to be reused but with different 13390 // compiled slot content. To avoid that, we generate a unique key based on 13391 // the generated code of all the slot contents. 13392 var needsKey = !!el.if; 13393 13394 // OR when it is inside another scoped slot or v-for (the reactivity may be 13395 // disconnected due to the intermediate scope variable) 13396 // #9438, #9506 13397 // TODO: this can be further optimized by properly analyzing in-scope bindings 13398 // and skip force updating ones that do not actually use scope variables. 13399 if (!needsForceUpdate) { 13400 var parent = el.parent; 13401 while (parent) { 13402 if ( 13403 (parent.slotScope && parent.slotScope !== emptySlotScopeToken) || 13404 parent.for 13405 ) { 13406 needsForceUpdate = true; 13407 break 13408 } 13409 if (parent.if) { 13410 needsKey = true; 13411 } 13412 parent = parent.parent; 13413 } 13414 } 13415 13416 var generatedSlots = Object.keys(slots) 13417 .map(function (key) { return genScopedSlot(slots[key], state); }) 13418 .join(','); 13419 13420 return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")") 13421} 13422 13423function hash(str) { 13424 var hash = 5381; 13425 var i = str.length; 13426 while(i) { 13427 hash = (hash * 33) ^ str.charCodeAt(--i); 13428 } 13429 return hash >>> 0 13430} 13431 13432function containsSlotChild (el) { 13433 if (el.type === 1) { 13434 if (el.tag === 'slot') { 13435 return true 13436 } 13437 return el.children.some(containsSlotChild) 13438 } 13439 return false 13440} 13441 13442function genScopedSlot ( 13443 el, 13444 state 13445) { 13446 var isLegacySyntax = el.attrsMap['slot-scope']; 13447 if (el.if && !el.ifProcessed && !isLegacySyntax) { 13448 return genIf(el, state, genScopedSlot, "null") 13449 } 13450 if (el.for && !el.forProcessed) { 13451 return genFor(el, state, genScopedSlot) 13452 } 13453 var slotScope = el.slotScope === emptySlotScopeToken 13454 ? "" 13455 : String(el.slotScope); 13456 var fn = "function(" + slotScope + "){" + 13457 "return " + (el.tag === 'template' 13458 ? el.if && isLegacySyntax 13459 ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined") 13460 : genChildren(el, state) || 'undefined' 13461 : genElement(el, state)) + "}"; 13462 // reverse proxy v-slot without scope on this.$slots 13463 var reverseProxy = slotScope ? "" : ",proxy:true"; 13464 return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}") 13465} 13466 13467function genChildren ( 13468 el, 13469 state, 13470 checkSkip, 13471 altGenElement, 13472 altGenNode 13473) { 13474 var children = el.children; 13475 if (children.length) { 13476 var el$1 = children[0]; 13477 // optimize single v-for 13478 if (children.length === 1 && 13479 el$1.for && 13480 el$1.tag !== 'template' && 13481 el$1.tag !== 'slot' 13482 ) { 13483 var normalizationType = checkSkip 13484 ? state.maybeComponent(el$1) ? ",1" : ",0" 13485 : ""; 13486 return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType) 13487 } 13488 var normalizationType$1 = checkSkip 13489 ? getNormalizationType(children, state.maybeComponent) 13490 : 0; 13491 var gen = altGenNode || genNode; 13492 return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : '')) 13493 } 13494} 13495 13496// determine the normalization needed for the children array. 13497// 0: no normalization needed 13498// 1: simple normalization needed (possible 1-level deep nested array) 13499// 2: full normalization needed 13500function getNormalizationType ( 13501 children, 13502 maybeComponent 13503) { 13504 var res = 0; 13505 for (var i = 0; i < children.length; i++) { 13506 var el = children[i]; 13507 if (el.type !== 1) { 13508 continue 13509 } 13510 if (needsNormalization(el) || 13511 (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) { 13512 res = 2; 13513 break 13514 } 13515 if (maybeComponent(el) || 13516 (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) { 13517 res = 1; 13518 } 13519 } 13520 return res 13521} 13522 13523function needsNormalization (el) { 13524 return el.for !== undefined || el.tag === 'template' || el.tag === 'slot' 13525} 13526 13527function genNode (node, state) { 13528 if (node.type === 1) { 13529 return genElement(node, state) 13530 } else if (node.type === 3 && node.isComment) { 13531 return genComment(node) 13532 } else { 13533 return genText(node) 13534 } 13535} 13536 13537function genText (text) { 13538 return ("_v(" + (text.type === 2 13539 ? text.expression // no need for () because already wrapped in _s() 13540 : transformSpecialNewlines(JSON.stringify(text.text))) + ")") 13541} 13542 13543function genComment (comment) { 13544 return ("_e(" + (JSON.stringify(comment.text)) + ")") 13545} 13546 13547function genSlot (el, state) { 13548 var slotName = el.slotName || '"default"'; 13549 var children = genChildren(el, state); 13550 var res = "_t(" + slotName + (children ? (",function(){return " + children + "}") : ''); 13551 var attrs = el.attrs || el.dynamicAttrs 13552 ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({ 13553 // slot props are camelized 13554 name: camelize(attr.name), 13555 value: attr.value, 13556 dynamic: attr.dynamic 13557 }); })) 13558 : null; 13559 var bind$$1 = el.attrsMap['v-bind']; 13560 if ((attrs || bind$$1) && !children) { 13561 res += ",null"; 13562 } 13563 if (attrs) { 13564 res += "," + attrs; 13565 } 13566 if (bind$$1) { 13567 res += (attrs ? '' : ',null') + "," + bind$$1; 13568 } 13569 return res + ')' 13570} 13571 13572// componentName is el.component, take it as argument to shun flow's pessimistic refinement 13573function genComponent ( 13574 componentName, 13575 el, 13576 state 13577) { 13578 var children = el.inlineTemplate ? null : genChildren(el, state, true); 13579 return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")") 13580} 13581 13582function genProps (props) { 13583 var staticProps = ""; 13584 var dynamicProps = ""; 13585 for (var i = 0; i < props.length; i++) { 13586 var prop = props[i]; 13587 var value = transformSpecialNewlines(prop.value); 13588 if (prop.dynamic) { 13589 dynamicProps += (prop.name) + "," + value + ","; 13590 } else { 13591 staticProps += "\"" + (prop.name) + "\":" + value + ","; 13592 } 13593 } 13594 staticProps = "{" + (staticProps.slice(0, -1)) + "}"; 13595 if (dynamicProps) { 13596 return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])") 13597 } else { 13598 return staticProps 13599 } 13600} 13601 13602// #3895, #4268 13603function transformSpecialNewlines (text) { 13604 return text 13605 .replace(/\u2028/g, '\\u2028') 13606 .replace(/\u2029/g, '\\u2029') 13607} 13608 13609/* */ 13610 13611 13612 13613// these keywords should not appear inside expressions, but operators like 13614// typeof, instanceof and in are allowed 13615var prohibitedKeywordRE = new RegExp('\\b' + ( 13616 'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 13617 'super,throw,while,yield,delete,export,import,return,switch,default,' + 13618 'extends,finally,continue,debugger,function,arguments' 13619).split(',').join('\\b|\\b') + '\\b'); 13620 13621// these unary operators should not be used as property/method names 13622var unaryOperatorsRE = new RegExp('\\b' + ( 13623 'delete,typeof,void' 13624).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)'); 13625 13626// strip strings in expressions 13627var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g; 13628 13629// detect problematic expressions in a template 13630function detectErrors (ast, warn) { 13631 if (ast) { 13632 checkNode(ast, warn); 13633 } 13634} 13635 13636function checkNode (node, warn) { 13637 if (node.type === 1) { 13638 for (var name in node.attrsMap) { 13639 if (dirRE.test(name)) { 13640 var value = node.attrsMap[name]; 13641 if (value) { 13642 var range = node.rawAttrsMap[name]; 13643 if (name === 'v-for') { 13644 checkFor(node, ("v-for=\"" + value + "\""), warn, range); 13645 } else if (name === 'v-slot' || name[0] === '#') { 13646 checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range); 13647 } else if (onRE.test(name)) { 13648 checkEvent(value, (name + "=\"" + value + "\""), warn, range); 13649 } else { 13650 checkExpression(value, (name + "=\"" + value + "\""), warn, range); 13651 } 13652 } 13653 } 13654 } 13655 if (node.children) { 13656 for (var i = 0; i < node.children.length; i++) { 13657 checkNode(node.children[i], warn); 13658 } 13659 } 13660 } else if (node.type === 2) { 13661 checkExpression(node.expression, node.text, warn, node); 13662 } 13663} 13664 13665function checkEvent (exp, text, warn, range) { 13666 var stripped = exp.replace(stripStringRE, ''); 13667 var keywordMatch = stripped.match(unaryOperatorsRE); 13668 if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') { 13669 warn( 13670 "avoid using JavaScript unary operator as property name: " + 13671 "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), 13672 range 13673 ); 13674 } 13675 checkExpression(exp, text, warn, range); 13676} 13677 13678function checkFor (node, text, warn, range) { 13679 checkExpression(node.for || '', text, warn, range); 13680 checkIdentifier(node.alias, 'v-for alias', text, warn, range); 13681 checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range); 13682 checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range); 13683} 13684 13685function checkIdentifier ( 13686 ident, 13687 type, 13688 text, 13689 warn, 13690 range 13691) { 13692 if (typeof ident === 'string') { 13693 try { 13694 new Function(("var " + ident + "=_")); 13695 } catch (e) { 13696 warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range); 13697 } 13698 } 13699} 13700 13701function checkExpression (exp, text, warn, range) { 13702 try { 13703 new Function(("return " + exp)); 13704 } catch (e) { 13705 var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE); 13706 if (keywordMatch) { 13707 warn( 13708 "avoid using JavaScript keyword as property name: " + 13709 "\"" + (keywordMatch[0]) + "\"\n Raw expression: " + (text.trim()), 13710 range 13711 ); 13712 } else { 13713 warn( 13714 "invalid expression: " + (e.message) + " in\n\n" + 13715 " " + exp + "\n\n" + 13716 " Raw expression: " + (text.trim()) + "\n", 13717 range 13718 ); 13719 } 13720 } 13721} 13722 13723function checkFunctionParameterExpression (exp, text, warn, range) { 13724 try { 13725 new Function(exp, ''); 13726 } catch (e) { 13727 warn( 13728 "invalid function parameter expression: " + (e.message) + " in\n\n" + 13729 " " + exp + "\n\n" + 13730 " Raw expression: " + (text.trim()) + "\n", 13731 range 13732 ); 13733 } 13734} 13735 13736/* */ 13737 13738var range = 2; 13739 13740function generateCodeFrame ( 13741 source, 13742 start, 13743 end 13744) { 13745 if ( start === void 0 ) start = 0; 13746 if ( end === void 0 ) end = source.length; 13747 13748 var lines = source.split(/\r?\n/); 13749 var count = 0; 13750 var res = []; 13751 for (var i = 0; i < lines.length; i++) { 13752 count += lines[i].length + 1; 13753 if (count >= start) { 13754 for (var j = i - range; j <= i + range || end > count; j++) { 13755 if (j < 0 || j >= lines.length) { continue } 13756 res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "| " + (lines[j]))); 13757 var lineLength = lines[j].length; 13758 if (j === i) { 13759 // push underline 13760 var pad = start - (count - lineLength) + 1; 13761 var length = end > count ? lineLength - pad : end - start; 13762 res.push(" | " + repeat$1(" ", pad) + repeat$1("^", length)); 13763 } else if (j > i) { 13764 if (end > count) { 13765 var length$1 = Math.min(end - count, lineLength); 13766 res.push(" | " + repeat$1("^", length$1)); 13767 } 13768 count += lineLength + 1; 13769 } 13770 } 13771 break 13772 } 13773 } 13774 return res.join('\n') 13775} 13776 13777function repeat$1 (str, n) { 13778 var result = ''; 13779 if (n > 0) { 13780 while (true) { // eslint-disable-line 13781 if (n & 1) { result += str; } 13782 n >>>= 1; 13783 if (n <= 0) { break } 13784 str += str; 13785 } 13786 } 13787 return result 13788} 13789 13790/* */ 13791 13792 13793 13794function createFunction (code, errors) { 13795 try { 13796 return new Function(code) 13797 } catch (err) { 13798 errors.push({ err: err, code: code }); 13799 return noop 13800 } 13801} 13802 13803function createCompileToFunctionFn (compile) { 13804 var cache = Object.create(null); 13805 13806 return function compileToFunctions ( 13807 template, 13808 options, 13809 vm 13810 ) { 13811 options = extend({}, options); 13812 var warn$$1 = options.warn || warn; 13813 delete options.warn; 13814 13815 /* istanbul ignore if */ 13816 { 13817 // detect possible CSP restriction 13818 try { 13819 new Function('return 1'); 13820 } catch (e) { 13821 if (e.toString().match(/unsafe-eval|CSP/)) { 13822 warn$$1( 13823 'It seems you are using the standalone build of Vue.js in an ' + 13824 'environment with Content Security Policy that prohibits unsafe-eval. ' + 13825 'The template compiler cannot work in this environment. Consider ' + 13826 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + 13827 'templates into render functions.' 13828 ); 13829 } 13830 } 13831 } 13832 13833 // check cache 13834 var key = options.delimiters 13835 ? String(options.delimiters) + template 13836 : template; 13837 if (cache[key]) { 13838 return cache[key] 13839 } 13840 13841 // compile 13842 var compiled = compile(template, options); 13843 13844 // check compilation errors/tips 13845 { 13846 if (compiled.errors && compiled.errors.length) { 13847 if (options.outputSourceRange) { 13848 compiled.errors.forEach(function (e) { 13849 warn$$1( 13850 "Error compiling template:\n\n" + (e.msg) + "\n\n" + 13851 generateCodeFrame(template, e.start, e.end), 13852 vm 13853 ); 13854 }); 13855 } else { 13856 warn$$1( 13857 "Error compiling template:\n\n" + template + "\n\n" + 13858 compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n', 13859 vm 13860 ); 13861 } 13862 } 13863 if (compiled.tips && compiled.tips.length) { 13864 if (options.outputSourceRange) { 13865 compiled.tips.forEach(function (e) { return tip(e.msg, vm); }); 13866 } else { 13867 compiled.tips.forEach(function (msg) { return tip(msg, vm); }); 13868 } 13869 } 13870 } 13871 13872 // turn code into functions 13873 var res = {}; 13874 var fnGenErrors = []; 13875 res.render = createFunction(compiled.render, fnGenErrors); 13876 res.staticRenderFns = compiled.staticRenderFns.map(function (code) { 13877 return createFunction(code, fnGenErrors) 13878 }); 13879 13880 // check function generation errors. 13881 // this should only happen if there is a bug in the compiler itself. 13882 // mostly for codegen development use 13883 /* istanbul ignore if */ 13884 { 13885 if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) { 13886 warn$$1( 13887 "Failed to generate render function:\n\n" + 13888 fnGenErrors.map(function (ref) { 13889 var err = ref.err; 13890 var code = ref.code; 13891 13892 return ((err.toString()) + " in\n\n" + code + "\n"); 13893 }).join('\n'), 13894 vm 13895 ); 13896 } 13897 } 13898 13899 return (cache[key] = res) 13900 } 13901} 13902 13903/* */ 13904 13905function createCompilerCreator (baseCompile) { 13906 return function createCompiler (baseOptions) { 13907 function compile ( 13908 template, 13909 options 13910 ) { 13911 var finalOptions = Object.create(baseOptions); 13912 var errors = []; 13913 var tips = []; 13914 13915 var warn = function (msg, range, tip) { 13916 (tip ? tips : errors).push(msg); 13917 }; 13918 13919 if (options) { 13920 if (options.outputSourceRange) { 13921 // $flow-disable-line 13922 var leadingSpaceLength = template.match(/^\s*/)[0].length; 13923 13924 warn = function (msg, range, tip) { 13925 var data = { msg: msg }; 13926 if (range) { 13927 if (range.start != null) { 13928 data.start = range.start + leadingSpaceLength; 13929 } 13930 if (range.end != null) { 13931 data.end = range.end + leadingSpaceLength; 13932 } 13933 } 13934 (tip ? tips : errors).push(data); 13935 }; 13936 } 13937 // merge custom modules 13938 if (options.modules) { 13939 finalOptions.modules = 13940 (baseOptions.modules || []).concat(options.modules); 13941 } 13942 // merge custom directives 13943 if (options.directives) { 13944 finalOptions.directives = extend( 13945 Object.create(baseOptions.directives || null), 13946 options.directives 13947 ); 13948 } 13949 // copy other options 13950 for (var key in options) { 13951 if (key !== 'modules' && key !== 'directives') { 13952 finalOptions[key] = options[key]; 13953 } 13954 } 13955 } 13956 13957 finalOptions.warn = warn; 13958 13959 var compiled = baseCompile(template.trim(), finalOptions); 13960 { 13961 detectErrors(compiled.ast, warn); 13962 } 13963 compiled.errors = errors; 13964 compiled.tips = tips; 13965 return compiled 13966 } 13967 13968 return { 13969 compile: compile, 13970 compileToFunctions: createCompileToFunctionFn(compile) 13971 } 13972 } 13973} 13974 13975/* */ 13976 13977// `createCompilerCreator` allows creating compilers that use alternative 13978// parser/optimizer/codegen, e.g the SSR optimizing compiler. 13979// Here we just export a default compiler using the default parts. 13980var createCompiler = createCompilerCreator(function baseCompile ( 13981 template, 13982 options 13983) { 13984 var ast = parse(template.trim(), options); 13985 if (options.optimize !== false) { 13986 optimize(ast, options); 13987 } 13988 var code = generate(ast, options); 13989 return { 13990 ast: ast, 13991 render: code.render, 13992 staticRenderFns: code.staticRenderFns 13993 } 13994}); 13995 13996/* */ 13997 13998var ref$1 = createCompiler(baseOptions); 13999var compile = ref$1.compile; 14000var compileToFunctions = ref$1.compileToFunctions; 14001 14002/* */ 14003 14004// check whether current browser encodes a char inside attribute values 14005var div; 14006function getShouldDecode (href) { 14007 div = div || document.createElement('div'); 14008 div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>"; 14009 return div.innerHTML.indexOf(' ') > 0 14010} 14011 14012// #3663: IE encodes newlines inside attribute values while other browsers don't 14013var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false; 14014// #6828: chrome encodes content in a[href] 14015var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false; 14016 14017/* */ 14018 14019var idToTemplate = cached(function (id) { 14020 var el = query(id); 14021 return el && el.innerHTML 14022}); 14023 14024var mount = Vue.prototype.$mount; 14025Vue.prototype.$mount = function ( 14026 el, 14027 hydrating 14028) { 14029 el = el && query(el); 14030 14031 /* istanbul ignore if */ 14032 if (el === document.body || el === document.documentElement) { 14033 warn( 14034 "Do not mount Vue to <html> or <body> - mount to normal elements instead." 14035 ); 14036 return this 14037 } 14038 14039 var options = this.$options; 14040 // resolve template/el and convert to render function 14041 if (!options.render) { 14042 var template = options.template; 14043 if (template) { 14044 if (typeof template === 'string') { 14045 if (template.charAt(0) === '#') { 14046 template = idToTemplate(template); 14047 /* istanbul ignore if */ 14048 if (!template) { 14049 warn( 14050 ("Template element not found or is empty: " + (options.template)), 14051 this 14052 ); 14053 } 14054 } 14055 } else if (template.nodeType) { 14056 template = template.innerHTML; 14057 } else { 14058 { 14059 warn('invalid template option:' + template, this); 14060 } 14061 return this 14062 } 14063 } else if (el) { 14064 template = getOuterHTML(el); 14065 } 14066 if (template) { 14067 /* istanbul ignore if */ 14068 if (config.performance && mark) { 14069 mark('compile'); 14070 } 14071 14072 var ref = compileToFunctions(template, { 14073 outputSourceRange: "development" !== 'production', 14074 shouldDecodeNewlines: shouldDecodeNewlines, 14075 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, 14076 delimiters: options.delimiters, 14077 comments: options.comments 14078 }, this); 14079 var render = ref.render; 14080 var staticRenderFns = ref.staticRenderFns; 14081 options.render = render; 14082 options.staticRenderFns = staticRenderFns; 14083 14084 /* istanbul ignore if */ 14085 if (config.performance && mark) { 14086 mark('compile end'); 14087 measure(("vue " + (this._name) + " compile"), 'compile', 'compile end'); 14088 } 14089 } 14090 } 14091 return mount.call(this, el, hydrating) 14092}; 14093 14094/** 14095 * Get outerHTML of elements, taking care 14096 * of SVG elements in IE as well. 14097 */ 14098function getOuterHTML (el) { 14099 if (el.outerHTML) { 14100 return el.outerHTML 14101 } else { 14102 var container = document.createElement('div'); 14103 container.appendChild(el.cloneNode(true)); 14104 return container.innerHTML 14105 } 14106} 14107 14108Vue.compile = compileToFunctions; 14109 14110module.exports = Vue; 14111 14112/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../../timers-browserify/main.js */ "./node_modules/timers-browserify/main.js").setImmediate)) 14113 14114/***/ }), 14115
vendor: 434 bytes, lines 14116-14129
14116/***/ "./node_modules/vue/dist/vue.common.js": 14117/*!*********************************************!*\ 14118 !*** ./node_modules/vue/dist/vue.common.js ***! 14119 \*********************************************/ 14120/*! no static exports found */ 14121/***/ (function(module, exports, __webpack_require__) { 14122 14123if (false) {} else { 14124 module.exports = __webpack_require__(/*! ./vue.common.dev.js */ "./node_modules/vue/dist/vue.common.dev.js") 14125} 14126 14127 14128/***/ }), 14129
vendor: 37,897 bytes, lines 14130-15394
14130/***/ "./node_modules/vuex/dist/vuex.esm.js": 14131/*!********************************************!*\ 14132 !*** ./node_modules/vuex/dist/vuex.esm.js ***! 14133 \********************************************/ 14134/*! exports provided: default, Store, createLogger, createNamespacedHelpers, install, mapActions, mapGetters, mapMutations, mapState */ 14135/***/ (function(module, __webpack_exports__, __webpack_require__) { 14136 14137"use strict"; 14138__webpack_require__.r(__webpack_exports__); 14139/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Store", function() { return Store; }); 14140/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createLogger", function() { return createLogger; }); 14141/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createNamespacedHelpers", function() { return createNamespacedHelpers; }); 14142/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "install", function() { return install; }); 14143/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapActions", function() { return mapActions; }); 14144/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapGetters", function() { return mapGetters; }); 14145/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapMutations", function() { return mapMutations; }); 14146/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapState", function() { return mapState; }); 14147/*! 14148 * vuex v3.6.2 14149 * (c) 2021 Evan You 14150 * @license MIT 14151 */ 14152function applyMixin (Vue) { 14153 var version = Number(Vue.version.split('.')[0]); 14154 14155 if (version >= 2) { 14156 Vue.mixin({ beforeCreate: vuexInit }); 14157 } else { 14158 // override init and inject vuex init procedure 14159 // for 1.x backwards compatibility. 14160 var _init = Vue.prototype._init; 14161 Vue.prototype._init = function (options) { 14162 if ( options === void 0 ) options = {}; 14163 14164 options.init = options.init 14165 ? [vuexInit].concat(options.init) 14166 : vuexInit; 14167 _init.call(this, options); 14168 }; 14169 } 14170 14171 /** 14172 * Vuex init hook, injected into each instances init hooks list. 14173 */ 14174 14175 function vuexInit () { 14176 var options = this.$options; 14177 // store injection 14178 if (options.store) { 14179 this.$store = typeof options.store === 'function' 14180 ? options.store() 14181 : options.store; 14182 } else if (options.parent && options.parent.$store) { 14183 this.$store = options.parent.$store; 14184 } 14185 } 14186} 14187 14188var target = typeof window !== 'undefined' 14189 ? window 14190 : typeof global !== 'undefined' 14191 ? global 14192 : {}; 14193var devtoolHook = target.__VUE_DEVTOOLS_GLOBAL_HOOK__; 14194 14195function devtoolPlugin (store) { 14196 if (!devtoolHook) { return } 14197 14198 store._devtoolHook = devtoolHook; 14199 14200 devtoolHook.emit('vuex:init', store); 14201 14202 devtoolHook.on('vuex:travel-to-state', function (targetState) { 14203 store.replaceState(targetState); 14204 }); 14205 14206 store.subscribe(function (mutation, state) { 14207 devtoolHook.emit('vuex:mutation', mutation, state); 14208 }, { prepend: true }); 14209 14210 store.subscribeAction(function (action, state) { 14211 devtoolHook.emit('vuex:action', action, state); 14212 }, { prepend: true }); 14213} 14214 14215/** 14216 * Get the first item that pass the test 14217 * by second argument function 14218 * 14219 * @param {Array} list 14220 * @param {Function} f 14221 * @return {*} 14222 */ 14223function find (list, f) { 14224 return list.filter(f)[0] 14225} 14226 14227/** 14228 * Deep copy the given object considering circular structure. 14229 * This function caches all nested objects and its copies. 14230 * If it detects circular structure, use cached copy to avoid infinite loop. 14231 * 14232 * @param {*} obj 14233 * @param {Array<Object>} cache 14234 * @return {*} 14235 */ 14236function deepCopy (obj, cache) { 14237 if ( cache === void 0 ) cache = []; 14238 14239 // just return if obj is immutable value 14240 if (obj === null || typeof obj !== 'object') { 14241 return obj 14242 } 14243 14244 // if obj is hit, it is in circular structure 14245 var hit = find(cache, function (c) { return c.original === obj; }); 14246 if (hit) { 14247 return hit.copy 14248 } 14249 14250 var copy = Array.isArray(obj) ? [] : {}; 14251 // put the copy into cache at first 14252 // because we want to refer it in recursive deepCopy 14253 cache.push({ 14254 original: obj, 14255 copy: copy 14256 }); 14257 14258 Object.keys(obj).forEach(function (key) { 14259 copy[key] = deepCopy(obj[key], cache); 14260 }); 14261 14262 return copy 14263} 14264 14265/** 14266 * forEach for object 14267 */ 14268function forEachValue (obj, fn) { 14269 Object.keys(obj).forEach(function (key) { return fn(obj[key], key); }); 14270} 14271 14272function isObject (obj) { 14273 return obj !== null && typeof obj === 'object' 14274} 14275 14276function isPromise (val) { 14277 return val && typeof val.then === 'function' 14278} 14279 14280function assert (condition, msg) { 14281 if (!condition) { throw new Error(("[vuex] " + msg)) } 14282} 14283 14284function partial (fn, arg) { 14285 return function () { 14286 return fn(arg) 14287 } 14288} 14289 14290// Base data struct for store's module, package with some attribute and method 14291var Module = function Module (rawModule, runtime) { 14292 this.runtime = runtime; 14293 // Store some children item 14294 this._children = Object.create(null); 14295 // Store the origin module object which passed by programmer 14296 this._rawModule = rawModule; 14297 var rawState = rawModule.state; 14298 14299 // Store the origin module's state 14300 this.state = (typeof rawState === 'function' ? rawState() : rawState) || {}; 14301}; 14302 14303var prototypeAccessors = { namespaced: { configurable: true } }; 14304 14305prototypeAccessors.namespaced.get = function () { 14306 return !!this._rawModule.namespaced 14307}; 14308 14309Module.prototype.addChild = function addChild (key, module) { 14310 this._children[key] = module; 14311}; 14312 14313Module.prototype.removeChild = function removeChild (key) { 14314 delete this._children[key]; 14315}; 14316 14317Module.prototype.getChild = function getChild (key) { 14318 return this._children[key] 14319}; 14320 14321Module.prototype.hasChild = function hasChild (key) { 14322 return key in this._children 14323}; 14324 14325Module.prototype.update = function update (rawModule) { 14326 this._rawModule.namespaced = rawModule.namespaced; 14327 if (rawModule.actions) { 14328 this._rawModule.actions = rawModule.actions; 14329 } 14330 if (rawModule.mutations) { 14331 this._rawModule.mutations = rawModule.mutations; 14332 } 14333 if (rawModule.getters) { 14334 this._rawModule.getters = rawModule.getters; 14335 } 14336}; 14337 14338Module.prototype.forEachChild = function forEachChild (fn) { 14339 forEachValue(this._children, fn); 14340}; 14341 14342Module.prototype.forEachGetter = function forEachGetter (fn) { 14343 if (this._rawModule.getters) { 14344 forEachValue(this._rawModule.getters, fn); 14345 } 14346}; 14347 14348Module.prototype.forEachAction = function forEachAction (fn) { 14349 if (this._rawModule.actions) { 14350 forEachValue(this._rawModule.actions, fn); 14351 } 14352}; 14353 14354Module.prototype.forEachMutation = function forEachMutation (fn) { 14355 if (this._rawModule.mutations) { 14356 forEachValue(this._rawModule.mutations, fn); 14357 } 14358}; 14359 14360Object.defineProperties( Module.prototype, prototypeAccessors ); 14361 14362var ModuleCollection = function ModuleCollection (rawRootModule) { 14363 // register root module (Vuex.Store options) 14364 this.register([], rawRootModule, false); 14365}; 14366 14367ModuleCollection.prototype.get = function get (path) { 14368 return path.reduce(function (module, key) { 14369 return module.getChild(key) 14370 }, this.root) 14371}; 14372 14373ModuleCollection.prototype.getNamespace = function getNamespace (path) { 14374 var module = this.root; 14375 return path.reduce(function (namespace, key) { 14376 module = module.getChild(key); 14377 return namespace + (module.namespaced ? key + '/' : '') 14378 }, '') 14379}; 14380 14381ModuleCollection.prototype.update = function update$1 (rawRootModule) { 14382 update([], this.root, rawRootModule); 14383}; 14384 14385ModuleCollection.prototype.register = function register (path, rawModule, runtime) { 14386 var this$1 = this; 14387 if ( runtime === void 0 ) runtime = true; 14388 14389 if ((true)) { 14390 assertRawModule(path, rawModule); 14391 } 14392 14393 var newModule = new Module(rawModule, runtime); 14394 if (path.length === 0) { 14395 this.root = newModule; 14396 } else { 14397 var parent = this.get(path.slice(0, -1)); 14398 parent.addChild(path[path.length - 1], newModule); 14399 } 14400 14401 // register nested modules 14402 if (rawModule.modules) { 14403 forEachValue(rawModule.modules, function (rawChildModule, key) { 14404 this$1.register(path.concat(key), rawChildModule, runtime); 14405 }); 14406 } 14407}; 14408 14409ModuleCollection.prototype.unregister = function unregister (path) { 14410 var parent = this.get(path.slice(0, -1)); 14411 var key = path[path.length - 1]; 14412 var child = parent.getChild(key); 14413 14414 if (!child) { 14415 if ((true)) { 14416 console.warn( 14417 "[vuex] trying to unregister module '" + key + "', which is " + 14418 "not registered" 14419 ); 14420 } 14421 return 14422 } 14423 14424 if (!child.runtime) { 14425 return 14426 } 14427 14428 parent.removeChild(key); 14429}; 14430 14431ModuleCollection.prototype.isRegistered = function isRegistered (path) { 14432 var parent = this.get(path.slice(0, -1)); 14433 var key = path[path.length - 1]; 14434 14435 if (parent) { 14436 return parent.hasChild(key) 14437 } 14438 14439 return false 14440}; 14441 14442function update (path, targetModule, newModule) { 14443 if ((true)) { 14444 assertRawModule(path, newModule); 14445 } 14446 14447 // update target module 14448 targetModule.update(newModule); 14449 14450 // update nested modules 14451 if (newModule.modules) { 14452 for (var key in newModule.modules) { 14453 if (!targetModule.getChild(key)) { 14454 if ((true)) { 14455 console.warn( 14456 "[vuex] trying to add a new module '" + key + "' on hot reloading, " + 14457 'manual reload is needed' 14458 ); 14459 } 14460 return 14461 } 14462 update( 14463 path.concat(key), 14464 targetModule.getChild(key), 14465 newModule.modules[key] 14466 ); 14467 } 14468 } 14469} 14470 14471var functionAssert = { 14472 assert: function (value) { return typeof value === 'function'; }, 14473 expected: 'function' 14474}; 14475 14476var objectAssert = { 14477 assert: function (value) { return typeof value === 'function' || 14478 (typeof value === 'object' && typeof value.handler === 'function'); }, 14479 expected: 'function or object with "handler" function' 14480}; 14481 14482var assertTypes = { 14483 getters: functionAssert, 14484 mutations: functionAssert, 14485 actions: objectAssert 14486}; 14487 14488function assertRawModule (path, rawModule) { 14489 Object.keys(assertTypes).forEach(function (key) { 14490 if (!rawModule[key]) { return } 14491 14492 var assertOptions = assertTypes[key]; 14493 14494 forEachValue(rawModule[key], function (value, type) { 14495 assert( 14496 assertOptions.assert(value), 14497 makeAssertionMessage(path, key, type, value, assertOptions.expected) 14498 ); 14499 }); 14500 }); 14501} 14502 14503function makeAssertionMessage (path, key, type, value, expected) { 14504 var buf = key + " should be " + expected + " but \"" + key + "." + type + "\""; 14505 if (path.length > 0) { 14506 buf += " in module \"" + (path.join('.')) + "\""; 14507 } 14508 buf += " is " + (JSON.stringify(value)) + "."; 14509 return buf 14510} 14511 14512var Vue; // bind on install 14513 14514var Store = function Store (options) { 14515 var this$1 = this; 14516 if ( options === void 0 ) options = {}; 14517 14518 // Auto install if it is not done yet and `window` has `Vue`. 14519 // To allow users to avoid auto-installation in some cases, 14520 // this code should be placed here. See #731 14521 if (!Vue && typeof window !== 'undefined' && window.Vue) { 14522 install(window.Vue); 14523 } 14524 14525 if ((true)) { 14526 assert(Vue, "must call Vue.use(Vuex) before creating a store instance."); 14527 assert(typeof Promise !== 'undefined', "vuex requires a Promise polyfill in this browser."); 14528 assert(this instanceof Store, "store must be called with the new operator."); 14529 } 14530 14531 var plugins = options.plugins; if ( plugins === void 0 ) plugins = []; 14532 var strict = options.strict; if ( strict === void 0 ) strict = false; 14533 14534 // store internal state 14535 this._committing = false; 14536 this._actions = Object.create(null); 14537 this._actionSubscribers = []; 14538 this._mutations = Object.create(null); 14539 this._wrappedGetters = Object.create(null); 14540 this._modules = new ModuleCollection(options); 14541 this._modulesNamespaceMap = Object.create(null); 14542 this._subscribers = []; 14543 this._watcherVM = new Vue(); 14544 this._makeLocalGettersCache = Object.create(null); 14545 14546 // bind commit and dispatch to self 14547 var store = this; 14548 var ref = this; 14549 var dispatch = ref.dispatch; 14550 var commit = ref.commit; 14551 this.dispatch = function boundDispatch (type, payload) { 14552 return dispatch.call(store, type, payload) 14553 }; 14554 this.commit = function boundCommit (type, payload, options) { 14555 return commit.call(store, type, payload, options) 14556 }; 14557 14558 // strict mode 14559 this.strict = strict; 14560 14561 var state = this._modules.root.state; 14562 14563 // init root module. 14564 // this also recursively registers all sub-modules 14565 // and collects all module getters inside this._wrappedGetters 14566 installModule(this, state, [], this._modules.root); 14567 14568 // initialize the store vm, which is responsible for the reactivity 14569 // (also registers _wrappedGetters as computed properties) 14570 resetStoreVM(this, state); 14571 14572 // apply plugins 14573 plugins.forEach(function (plugin) { return plugin(this$1); }); 14574 14575 var useDevtools = options.devtools !== undefined ? options.devtools : Vue.config.devtools; 14576 if (useDevtools) { 14577 devtoolPlugin(this); 14578 } 14579}; 14580 14581var prototypeAccessors$1 = { state: { configurable: true } }; 14582 14583prototypeAccessors$1.state.get = function () { 14584 return this._vm._data.$$state 14585}; 14586 14587prototypeAccessors$1.state.set = function (v) { 14588 if ((true)) { 14589 assert(false, "use store.replaceState() to explicit replace store state."); 14590 } 14591}; 14592 14593Store.prototype.commit = function commit (_type, _payload, _options) { 14594 var this$1 = this; 14595 14596 // check object-style commit 14597 var ref = unifyObjectStyle(_type, _payload, _options); 14598 var type = ref.type; 14599 var payload = ref.payload; 14600 var options = ref.options; 14601 14602 var mutation = { type: type, payload: payload }; 14603 var entry = this._mutations[type]; 14604 if (!entry) { 14605 if ((true)) { 14606 console.error(("[vuex] unknown mutation type: " + type)); 14607 } 14608 return 14609 } 14610 this._withCommit(function () { 14611 entry.forEach(function commitIterator (handler) { 14612 handler(payload); 14613 }); 14614 }); 14615 14616 this._subscribers 14617 .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe 14618 .forEach(function (sub) { return sub(mutation, this$1.state); }); 14619 14620 if ( 14621 ( true) && 14622 options && options.silent 14623 ) { 14624 console.warn( 14625 "[vuex] mutation type: " + type + ". Silent option has been removed. " + 14626 'Use the filter functionality in the vue-devtools' 14627 ); 14628 } 14629}; 14630 14631Store.prototype.dispatch = function dispatch (_type, _payload) { 14632 var this$1 = this; 14633 14634 // check object-style dispatch 14635 var ref = unifyObjectStyle(_type, _payload); 14636 var type = ref.type; 14637 var payload = ref.payload; 14638 14639 var action = { type: type, payload: payload }; 14640 var entry = this._actions[type]; 14641 if (!entry) { 14642 if ((true)) { 14643 console.error(("[vuex] unknown action type: " + type)); 14644 } 14645 return 14646 } 14647 14648 try { 14649 this._actionSubscribers 14650 .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe 14651 .filter(function (sub) { return sub.before; }) 14652 .forEach(function (sub) { return sub.before(action, this$1.state); }); 14653 } catch (e) { 14654 if ((true)) { 14655 console.warn("[vuex] error in before action subscribers: "); 14656 console.error(e); 14657 } 14658 } 14659 14660 var result = entry.length > 1 14661 ? Promise.all(entry.map(function (handler) { return handler(payload); })) 14662 : entry[0](payload); 14663 14664 return new Promise(function (resolve, reject) { 14665 result.then(function (res) { 14666 try { 14667 this$1._actionSubscribers 14668 .filter(function (sub) { return sub.after; }) 14669 .forEach(function (sub) { return sub.after(action, this$1.state); }); 14670 } catch (e) { 14671 if ((true)) { 14672 console.warn("[vuex] error in after action subscribers: "); 14673 console.error(e); 14674 } 14675 } 14676 resolve(res); 14677 }, function (error) { 14678 try { 14679 this$1._actionSubscribers 14680 .filter(function (sub) { return sub.error; }) 14681 .forEach(function (sub) { return sub.error(action, this$1.state, error); }); 14682 } catch (e) { 14683 if ((true)) { 14684 console.warn("[vuex] error in error action subscribers: "); 14685 console.error(e); 14686 } 14687 } 14688 reject(error); 14689 }); 14690 }) 14691}; 14692 14693Store.prototype.subscribe = function subscribe (fn, options) { 14694 return genericSubscribe(fn, this._subscribers, options) 14695}; 14696 14697Store.prototype.subscribeAction = function subscribeAction (fn, options) { 14698 var subs = typeof fn === 'function' ? { before: fn } : fn; 14699 return genericSubscribe(subs, this._actionSubscribers, options) 14700}; 14701 14702Store.prototype.watch = function watch (getter, cb, options) { 14703 var this$1 = this; 14704 14705 if ((true)) { 14706 assert(typeof getter === 'function', "store.watch only accepts a function."); 14707 } 14708 return this._watcherVM.$watch(function () { return getter(this$1.state, this$1.getters); }, cb, options) 14709}; 14710 14711Store.prototype.replaceState = function replaceState (state) { 14712 var this$1 = this; 14713 14714 this._withCommit(function () { 14715 this$1._vm._data.$$state = state; 14716 }); 14717}; 14718 14719Store.prototype.registerModule = function registerModule (path, rawModule, options) { 14720 if ( options === void 0 ) options = {}; 14721 14722 if (typeof path === 'string') { path = [path]; } 14723 14724 if ((true)) { 14725 assert(Array.isArray(path), "module path must be a string or an Array."); 14726 assert(path.length > 0, 'cannot register the root module by using registerModule.'); 14727 } 14728 14729 this._modules.register(path, rawModule); 14730 installModule(this, this.state, path, this._modules.get(path), options.preserveState); 14731 // reset store to update getters... 14732 resetStoreVM(this, this.state); 14733}; 14734 14735Store.prototype.unregisterModule = function unregisterModule (path) { 14736 var this$1 = this; 14737 14738 if (typeof path === 'string') { path = [path]; } 14739 14740 if ((true)) { 14741 assert(Array.isArray(path), "module path must be a string or an Array."); 14742 } 14743 14744 this._modules.unregister(path); 14745 this._withCommit(function () { 14746 var parentState = getNestedState(this$1.state, path.slice(0, -1)); 14747 Vue.delete(parentState, path[path.length - 1]); 14748 }); 14749 resetStore(this); 14750}; 14751 14752Store.prototype.hasModule = function hasModule (path) { 14753 if (typeof path === 'string') { path = [path]; } 14754 14755 if ((true)) { 14756 assert(Array.isArray(path), "module path must be a string or an Array."); 14757 } 14758 14759 return this._modules.isRegistered(path) 14760}; 14761 14762Store.prototype.hotUpdate = function hotUpdate (newOptions) { 14763 this._modules.update(newOptions); 14764 resetStore(this, true); 14765}; 14766 14767Store.prototype._withCommit = function _withCommit (fn) { 14768 var committing = this._committing; 14769 this._committing = true; 14770 fn(); 14771 this._committing = committing; 14772}; 14773 14774Object.defineProperties( Store.prototype, prototypeAccessors$1 ); 14775 14776function genericSubscribe (fn, subs, options) { 14777 if (subs.indexOf(fn) < 0) { 14778 options && options.prepend 14779 ? subs.unshift(fn) 14780 : subs.push(fn); 14781 } 14782 return function () { 14783 var i = subs.indexOf(fn); 14784 if (i > -1) { 14785 subs.splice(i, 1); 14786 } 14787 } 14788} 14789 14790function resetStore (store, hot) { 14791 store._actions = Object.create(null); 14792 store._mutations = Object.create(null); 14793 store._wrappedGetters = Object.create(null); 14794 store._modulesNamespaceMap = Object.create(null); 14795 var state = store.state; 14796 // init all modules 14797 installModule(store, state, [], store._modules.root, true); 14798 // reset vm 14799 resetStoreVM(store, state, hot); 14800} 14801 14802function resetStoreVM (store, state, hot) { 14803 var oldVm = store._vm; 14804 14805 // bind store public getters 14806 store.getters = {}; 14807 // reset local getters cache 14808 store._makeLocalGettersCache = Object.create(null); 14809 var wrappedGetters = store._wrappedGetters; 14810 var computed = {}; 14811 forEachValue(wrappedGetters, function (fn, key) { 14812 // use computed to leverage its lazy-caching mechanism 14813 // direct inline function use will lead to closure preserving oldVm. 14814 // using partial to return function with only arguments preserved in closure environment. 14815 computed[key] = partial(fn, store); 14816 Object.defineProperty(store.getters, key, { 14817 get: function () { return store._vm[key]; }, 14818 enumerable: true // for local getters 14819 }); 14820 }); 14821 14822 // use a Vue instance to store the state tree 14823 // suppress warnings just in case the user has added 14824 // some funky global mixins 14825 var silent = Vue.config.silent; 14826 Vue.config.silent = true; 14827 store._vm = new Vue({ 14828 data: { 14829 $$state: state 14830 }, 14831 computed: computed 14832 }); 14833 Vue.config.silent = silent; 14834 14835 // enable strict mode for new vm 14836 if (store.strict) { 14837 enableStrictMode(store); 14838 } 14839 14840 if (oldVm) { 14841 if (hot) { 14842 // dispatch changes in all subscribed watchers 14843 // to force getter re-evaluation for hot reloading. 14844 store._withCommit(function () { 14845 oldVm._data.$$state = null; 14846 }); 14847 } 14848 Vue.nextTick(function () { return oldVm.$destroy(); }); 14849 } 14850} 14851 14852function installModule (store, rootState, path, module, hot) { 14853 var isRoot = !path.length; 14854 var namespace = store._modules.getNamespace(path); 14855 14856 // register in namespace map 14857 if (module.namespaced) { 14858 if (store._modulesNamespaceMap[namespace] && ("development" !== 'production')) { 14859 console.error(("[vuex] duplicate namespace " + namespace + " for the namespaced module " + (path.join('/')))); 14860 } 14861 store._modulesNamespaceMap[namespace] = module; 14862 } 14863 14864 // set state 14865 if (!isRoot && !hot) { 14866 var parentState = getNestedState(rootState, path.slice(0, -1)); 14867 var moduleName = path[path.length - 1]; 14868 store._withCommit(function () { 14869 if ((true)) { 14870 if (moduleName in parentState) { 14871 console.warn( 14872 ("[vuex] state field \"" + moduleName + "\" was overridden by a module with the same name at \"" + (path.join('.')) + "\"") 14873 ); 14874 } 14875 } 14876 Vue.set(parentState, moduleName, module.state); 14877 }); 14878 } 14879 14880 var local = module.context = makeLocalContext(store, namespace, path); 14881 14882 module.forEachMutation(function (mutation, key) { 14883 var namespacedType = namespace + key; 14884 registerMutation(store, namespacedType, mutation, local); 14885 }); 14886 14887 module.forEachAction(function (action, key) { 14888 var type = action.root ? key : namespace + key; 14889 var handler = action.handler || action; 14890 registerAction(store, type, handler, local); 14891 }); 14892 14893 module.forEachGetter(function (getter, key) { 14894 var namespacedType = namespace + key; 14895 registerGetter(store, namespacedType, getter, local); 14896 }); 14897 14898 module.forEachChild(function (child, key) { 14899 installModule(store, rootState, path.concat(key), child, hot); 14900 }); 14901} 14902 14903/** 14904 * make localized dispatch, commit, getters and state 14905 * if there is no namespace, just use root ones 14906 */ 14907function makeLocalContext (store, namespace, path) { 14908 var noNamespace = namespace === ''; 14909 14910 var local = { 14911 dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) { 14912 var args = unifyObjectStyle(_type, _payload, _options); 14913 var payload = args.payload; 14914 var options = args.options; 14915 var type = args.type; 14916 14917 if (!options || !options.root) { 14918 type = namespace + type; 14919 if (( true) && !store._actions[type]) { 14920 console.error(("[vuex] unknown local action type: " + (args.type) + ", global type: " + type)); 14921 return 14922 } 14923 } 14924 14925 return store.dispatch(type, payload) 14926 }, 14927 14928 commit: noNamespace ? store.commit : function (_type, _payload, _options) { 14929 var args = unifyObjectStyle(_type, _payload, _options); 14930 var payload = args.payload; 14931 var options = args.options; 14932 var type = args.type; 14933 14934 if (!options || !options.root) { 14935 type = namespace + type; 14936 if (( true) && !store._mutations[type]) { 14937 console.error(("[vuex] unknown local mutation type: " + (args.type) + ", global type: " + type)); 14938 return 14939 } 14940 } 14941 14942 store.commit(type, payload, options); 14943 } 14944 }; 14945 14946 // getters and state object must be gotten lazily 14947 // because they will be changed by vm update 14948 Object.defineProperties(local, { 14949 getters: { 14950 get: noNamespace 14951 ? function () { return store.getters; } 14952 : function () { return makeLocalGetters(store, namespace); } 14953 }, 14954 state: { 14955 get: function () { return getNestedState(store.state, path); } 14956 } 14957 }); 14958 14959 return local 14960} 14961 14962function makeLocalGetters (store, namespace) { 14963 if (!store._makeLocalGettersCache[namespace]) { 14964 var gettersProxy = {}; 14965 var splitPos = namespace.length; 14966 Object.keys(store.getters).forEach(function (type) { 14967 // skip if the target getter is not match this namespace 14968 if (type.slice(0, splitPos) !== namespace) { return } 14969 14970 // extract local getter type 14971 var localType = type.slice(splitPos); 14972 14973 // Add a port to the getters proxy. 14974 // Define as getter property because 14975 // we do not want to evaluate the getters in this time. 14976 Object.defineProperty(gettersProxy, localType, { 14977 get: function () { return store.getters[type]; }, 14978 enumerable: true 14979 }); 14980 }); 14981 store._makeLocalGettersCache[namespace] = gettersProxy; 14982 } 14983 14984 return store._makeLocalGettersCache[namespace] 14985} 14986 14987function registerMutation (store, type, handler, local) { 14988 var entry = store._mutations[type] || (store._mutations[type] = []); 14989 entry.push(function wrappedMutationHandler (payload) { 14990 handler.call(store, local.state, payload); 14991 }); 14992} 14993 14994function registerAction (store, type, handler, local) { 14995 var entry = store._actions[type] || (store._actions[type] = []); 14996 entry.push(function wrappedActionHandler (payload) { 14997 var res = handler.call(store, { 14998 dispatch: local.dispatch, 14999 commit: local.commit, 15000 getters: local.getters, 15001 state: local.state, 15002 rootGetters: store.getters, 15003 rootState: store.state 15004 }, payload); 15005 if (!isPromise(res)) { 15006 res = Promise.resolve(res); 15007 } 15008 if (store._devtoolHook) { 15009 return res.catch(function (err) { 15010 store._devtoolHook.emit('vuex:error', err); 15011 throw err 15012 }) 15013 } else { 15014 return res 15015 } 15016 }); 15017} 15018 15019function registerGetter (store, type, rawGetter, local) { 15020 if (store._wrappedGetters[type]) { 15021 if ((true)) { 15022 console.error(("[vuex] duplicate getter key: " + type)); 15023 } 15024 return 15025 } 15026 store._wrappedGetters[type] = function wrappedGetter (store) { 15027 return rawGetter( 15028 local.state, // local state 15029 local.getters, // local getters 15030 store.state, // root state 15031 store.getters // root getters 15032 ) 15033 }; 15034} 15035 15036function enableStrictMode (store) { 15037 store._vm.$watch(function () { return this._data.$$state }, function () { 15038 if ((true)) { 15039 assert(store._committing, "do not mutate vuex store state outside mutation handlers."); 15040 } 15041 }, { deep: true, sync: true }); 15042} 15043 15044function getNestedState (state, path) { 15045 return path.reduce(function (state, key) { return state[key]; }, state) 15046} 15047 15048function unifyObjectStyle (type, payload, options) { 15049 if (isObject(type) && type.type) { 15050 options = payload; 15051 payload = type; 15052 type = type.type; 15053 } 15054 15055 if ((true)) { 15056 assert(typeof type === 'string', ("expects string as the type, but found " + (typeof type) + ".")); 15057 } 15058 15059 return { type: type, payload: payload, options: options } 15060} 15061 15062function install (_Vue) { 15063 if (Vue && _Vue === Vue) { 15064 if ((true)) { 15065 console.error( 15066 '[vuex] already installed. Vue.use(Vuex) should be called only once.' 15067 ); 15068 } 15069 return 15070 } 15071 Vue = _Vue; 15072 applyMixin(Vue); 15073} 15074 15075/** 15076 * Reduce the code which written in Vue.js for getting the state. 15077 * @param {String} [namespace] - Module's namespace 15078 * @param {Object|Array} states # Object's item can be a function which accept state and getters for param, you can do something for state and getters in it. 15079 * @param {Object} 15080 */ 15081var mapState = normalizeNamespace(function (namespace, states) { 15082 var res = {}; 15083 if (( true) && !isValidMap(states)) { 15084 console.error('[vuex] mapState: mapper parameter must be either an Array or an Object'); 15085 } 15086 normalizeMap(states).forEach(function (ref) { 15087 var key = ref.key; 15088 var val = ref.val; 15089 15090 res[key] = function mappedState () { 15091 var state = this.$store.state; 15092 var getters = this.$store.getters; 15093 if (namespace) { 15094 var module = getModuleByNamespace(this.$store, 'mapState', namespace); 15095 if (!module) { 15096 return 15097 } 15098 state = module.context.state; 15099 getters = module.context.getters; 15100 } 15101 return typeof val === 'function' 15102 ? val.call(this, state, getters) 15103 : state[val] 15104 }; 15105 // mark vuex getter for devtools 15106 res[key].vuex = true; 15107 }); 15108 return res 15109}); 15110 15111/** 15112 * Reduce the code which written in Vue.js for committing the mutation 15113 * @param {String} [namespace] - Module's namespace 15114 * @param {Object|Array} mutations # Object's item can be a function which accept `commit` function as the first param, it can accept another params. You can commit mutation and do any other things in this function. specially, You need to pass anthor params from the mapped function. 15115 * @return {Object} 15116 */ 15117var mapMutations = normalizeNamespace(function (namespace, mutations) { 15118 var res = {}; 15119 if (( true) && !isValidMap(mutations)) { 15120 console.error('[vuex] mapMutations: mapper parameter must be either an Array or an Object'); 15121 } 15122 normalizeMap(mutations).forEach(function (ref) { 15123 var key = ref.key; 15124 var val = ref.val; 15125 15126 res[key] = function mappedMutation () { 15127 var args = [], len = arguments.length; 15128 while ( len-- ) args[ len ] = arguments[ len ]; 15129 15130 // Get the commit method from store 15131 var commit = this.$store.commit; 15132 if (namespace) { 15133 var module = getModuleByNamespace(this.$store, 'mapMutations', namespace); 15134 if (!module) { 15135 return 15136 } 15137 commit = module.context.commit; 15138 } 15139 return typeof val === 'function' 15140 ? val.apply(this, [commit].concat(args)) 15141 : commit.apply(this.$store, [val].concat(args)) 15142 }; 15143 }); 15144 return res 15145}); 15146 15147/** 15148 * Reduce the code which written in Vue.js for getting the getters 15149 * @param {String} [namespace] - Module's namespace 15150 * @param {Object|Array} getters 15151 * @return {Object} 15152 */ 15153var mapGetters = normalizeNamespace(function (namespace, getters) { 15154 var res = {}; 15155 if (( true) && !isValidMap(getters)) { 15156 console.error('[vuex] mapGetters: mapper parameter must be either an Array or an Object'); 15157 } 15158 normalizeMap(getters).forEach(function (ref) { 15159 var key = ref.key; 15160 var val = ref.val; 15161 15162 // The namespace has been mutated by normalizeNamespace 15163 val = namespace + val; 15164 res[key] = function mappedGetter () { 15165 if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) { 15166 return 15167 } 15168 if (( true) && !(val in this.$store.getters)) { 15169 console.error(("[vuex] unknown getter: " + val)); 15170 return 15171 } 15172 return this.$store.getters[val] 15173 }; 15174 // mark vuex getter for devtools 15175 res[key].vuex = true; 15176 }); 15177 return res 15178}); 15179 15180/** 15181 * Reduce the code which written in Vue.js for dispatch the action 15182 * @param {String} [namespace] - Module's namespace 15183 * @param {Object|Array} actions # Object's item can be a function which accept `dispatch` function as the first param, it can accept anthor params. You can dispatch action and do any other things in this function. specially, You need to pass anthor params from the mapped function. 15184 * @return {Object} 15185 */ 15186var mapActions = normalizeNamespace(function (namespace, actions) { 15187 var res = {}; 15188 if (( true) && !isValidMap(actions)) { 15189 console.error('[vuex] mapActions: mapper parameter must be either an Array or an Object'); 15190 } 15191 normalizeMap(actions).forEach(function (ref) { 15192 var key = ref.key; 15193 var val = ref.val; 15194 15195 res[key] = function mappedAction () { 15196 var args = [], len = arguments.length; 15197 while ( len-- ) args[ len ] = arguments[ len ]; 15198 15199 // get dispatch function from store 15200 var dispatch = this.$store.dispatch; 15201 if (namespace) { 15202 var module = getModuleByNamespace(this.$store, 'mapActions', namespace); 15203 if (!module) { 15204 return 15205 } 15206 dispatch = module.context.dispatch; 15207 } 15208 return typeof val === 'function' 15209 ? val.apply(this, [dispatch].concat(args)) 15210 : dispatch.apply(this.$store, [val].concat(args)) 15211 }; 15212 }); 15213 return res 15214}); 15215 15216/** 15217 * Rebinding namespace param for mapXXX function in special scoped, and return them by simple object 15218 * @param {String} namespace 15219 * @return {Object} 15220 */ 15221var createNamespacedHelpers = function (namespace) { return ({ 15222 mapState: mapState.bind(null, namespace), 15223 mapGetters: mapGetters.bind(null, namespace), 15224 mapMutations: mapMutations.bind(null, namespace), 15225 mapActions: mapActions.bind(null, namespace) 15226}); }; 15227 15228/** 15229 * Normalize the map 15230 * normalizeMap([1, 2, 3]) => [ { key: 1, val: 1 }, { key: 2, val: 2 }, { key: 3, val: 3 } ] 15231 * normalizeMap({a: 1, b: 2, c: 3}) => [ { key: 'a', val: 1 }, { key: 'b', val: 2 }, { key: 'c', val: 3 } ] 15232 * @param {Array|Object} map 15233 * @return {Object} 15234 */ 15235function normalizeMap (map) { 15236 if (!isValidMap(map)) { 15237 return [] 15238 } 15239 return Array.isArray(map) 15240 ? map.map(function (key) { return ({ key: key, val: key }); }) 15241 : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); }) 15242} 15243 15244/** 15245 * Validate whether given map is valid or not 15246 * @param {*} map 15247 * @return {Boolean} 15248 */ 15249function isValidMap (map) { 15250 return Array.isArray(map) || isObject(map) 15251} 15252 15253/** 15254 * Return a function expect two param contains namespace and map. it will normalize the namespace and then the param's function will handle the new namespace and the map. 15255 * @param {Function} fn 15256 * @return {Function} 15257 */ 15258function normalizeNamespace (fn) { 15259 return function (namespace, map) { 15260 if (typeof namespace !== 'string') { 15261 map = namespace; 15262 namespace = ''; 15263 } else if (namespace.charAt(namespace.length - 1) !== '/') { 15264 namespace += '/'; 15265 } 15266 return fn(namespace, map) 15267 } 15268} 15269 15270/** 15271 * Search a special module from store by namespace. if module not exist, print error message. 15272 * @param {Object} store 15273 * @param {String} helper 15274 * @param {String} namespace 15275 * @return {Object} 15276 */ 15277function getModuleByNamespace (store, helper, namespace) { 15278 var module = store._modulesNamespaceMap[namespace]; 15279 if (( true) && !module) { 15280 console.error(("[vuex] module namespace not found in " + helper + "(): " + namespace)); 15281 } 15282 return module 15283} 15284 15285// Credits: borrowed code from fcomb/redux-logger 15286 15287function createLogger (ref) { 15288 if ( ref === void 0 ) ref = {}; 15289 var collapsed = ref.collapsed; if ( collapsed === void 0 ) collapsed = true; 15290 var filter = ref.filter; if ( filter === void 0 ) filter = function (mutation, stateBefore, stateAfter) { return true; }; 15291 var transformer = ref.transformer; if ( transformer === void 0 ) transformer = function (state) { return state; }; 15292 var mutationTransformer = ref.mutationTransformer; if ( mutationTransformer === void 0 ) mutationTransformer = function (mut) { return mut; }; 15293 var actionFilter = ref.actionFilter; if ( actionFilter === void 0 ) actionFilter = function (action, state) { return true; }; 15294 var actionTransformer = ref.actionTransformer; if ( actionTransformer === void 0 ) actionTransformer = function (act) { return act; }; 15295 var logMutations = ref.logMutations; if ( logMutations === void 0 ) logMutations = true; 15296 var logActions = ref.logActions; if ( logActions === void 0 ) logActions = true; 15297 var logger = ref.logger; if ( logger === void 0 ) logger = console; 15298 15299 return function (store) { 15300 var prevState = deepCopy(store.state); 15301 15302 if (typeof logger === 'undefined') { 15303 return 15304 } 15305 15306 if (logMutations) { 15307 store.subscribe(function (mutation, state) { 15308 var nextState = deepCopy(state); 15309 15310 if (filter(mutation, prevState, nextState)) { 15311 var formattedTime = getFormattedTime(); 15312 var formattedMutation = mutationTransformer(mutation); 15313 var message = "mutation " + (mutation.type) + formattedTime; 15314 15315 startMessage(logger, message, collapsed); 15316 logger.log('%c prev state', 'color: #9E9E9E; font-weight: bold', transformer(prevState)); 15317 logger.log('%c mutation', 'color: #03A9F4; font-weight: bold', formattedMutation); 15318 logger.log('%c next state', 'color: #4CAF50; font-weight: bold', transformer(nextState)); 15319 endMessage(logger); 15320 } 15321 15322 prevState = nextState; 15323 }); 15324 } 15325 15326 if (logActions) { 15327 store.subscribeAction(function (action, state) { 15328 if (actionFilter(action, state)) { 15329 var formattedTime = getFormattedTime(); 15330 var formattedAction = actionTransformer(action); 15331 var message = "action " + (action.type) + formattedTime; 15332 15333 startMessage(logger, message, collapsed); 15334 logger.log('%c action', 'color: #03A9F4; font-weight: bold', formattedAction); 15335 endMessage(logger); 15336 } 15337 }); 15338 } 15339 } 15340} 15341 15342function startMessage (logger, message, collapsed) { 15343 var startMessage = collapsed 15344 ? logger.groupCollapsed 15345 : logger.group; 15346 15347 // render 15348 try { 15349 startMessage.call(logger, message); 15350 } catch (e) { 15351 logger.log(message); 15352 } 15353} 15354 15355function endMessage (logger) { 15356 try { 15357 logger.groupEnd(); 15358 } catch (e) { 15359 logger.log('ââ log end ââ'); 15360 } 15361} 15362 15363function getFormattedTime () { 15364 var time = new Date(); 15365 return (" @ " + (pad(time.getHours(), 2)) + ":" + (pad(time.getMinutes(), 2)) + ":" + (pad(time.getSeconds(), 2)) + "." + (pad(time.getMilliseconds(), 3))) 15366} 15367 15368function repeat (str, times) { 15369 return (new Array(times + 1)).join(str) 15370} 15371 15372function pad (num, maxLength) { 15373 return repeat('0', maxLength - num.toString().length) + num 15374} 15375 15376var index = { 15377 Store: Store, 15378 install: install, 15379 version: '3.6.2', 15380 mapState: mapState, 15381 mapMutations: mapMutations, 15382 mapGetters: mapGetters, 15383 mapActions: mapActions, 15384 createNamespacedHelpers: createNamespacedHelpers, 15385 createLogger: createLogger 15386}; 15387 15388/* harmony default export */ __webpack_exports__["default"] = (index); 15389 15390 15391/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) 15392 15393/***/ }), 15394
vendor: 721 bytes, lines 15395-15424
15395/***/ "./node_modules/webpack/buildin/global.js": 15396/*!***********************************!*\ 15397 !*** (webpack)/buildin/global.js ***! 15398 \***********************************/ 15399/*! no static exports found */ 15400/***/ (function(module, exports) { 15401 15402var g; 15403 15404// This works in non-strict mode 15405g = (function() { 15406 return this; 15407})(); 15408 15409try { 15410 // This works if eval is allowed (see CSP) 15411 g = g || new Function("return this")(); 15412} catch (e) { 15413 // This works if the window reference is available 15414 if (typeof window === "object") g = window; 15415} 15416 15417// g can still be undefined, but nothing to do about it... 15418// We return undefined, instead of nothing here, so it's 15419// easier to handle this case. if(!global) { ...} 15420 15421module.exports = g; 15422 15423 15424/***/ })
15424, 15425 15426/***/ 1: 15427/*!****************************!*\ 15428 !*** multi axios vue vuex ***! 15429 \****************************/ 15430/*! no static exports found */ 15431/***/ (function(module, exports, __webpack_require__) { 15432 15433__webpack_require__(/*! axios */"./node_modules/axios/index.js"); 15434__webpack_require__(/*! vue */"./node_modules/vue/dist/vue.common.js"); 15435module.exports = __webpack_require__(/*! vuex */"./node_modules/vuex/dist/vuex.esm.js"); 15436 15437 15438/***/ }) 15439 15440},[[1,"/web/dist/js/manifest"]]]); 15441//# sourceMappingURL=vendor.js.map
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.