☰

Greasy Fork is available in English.

vue.js

Vue

Script này sẽ không được không được cài đặt trực tiếp. Nó là một thư viện cho các script khác để bao gồm các chỉ thị meta // @require https://update.greatest.deepsurf.us/scripts/38348/250278/vuejs.js 

  1. /*!
  2.  * Vue.js v2.5.13
  3.  * (c) 2014-2017 Evan You
  4.  * Released under the MIT License.
  5.  */
  6. (function (global, factory) {
  7. 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  8. 	typeof define === 'function' && define.amd ? define(factory) :
  9. 	(global.Vue = factory());
  10. }(this, (function () { 'use strict';
  11.  
  12. /*  */
  13.  
  14. var emptyObject = Object.freeze({});
  15.  
  16. // these helpers produces better vm code in JS engines due to their
  17. // explicitness and function inlining
  18. function isUndef (v) {
  19.   return v === undefined || v === null
  20. }
  21.  
  22. function isDef (v) {
  23.   return v !== undefined && v !== null
  24. }
  25.  
  26. function isTrue (v) {
  27.   return v === true
  28. }
  29.  
  30. function isFalse (v) {
  31.   return v === false
  32. }
  33.  
  34. /**
  35.  * Check if value is primitive
  36.  */
  37. function isPrimitive (value) {
  38.   return (
  39.     typeof value === 'string' ||
  40.     typeof value === 'number' ||
  41.     // $flow-disable-line
  42.     typeof value === 'symbol' ||
  43.     typeof value === 'boolean'
  44.   )
  45. }
  46.  
  47. /**
  48.  * Quick object check - this is primarily used to tell
  49.  * Objects from primitive values when we know the value
  50.  * is a JSON-compliant type.
  51.  */
  52. function isObject (obj) {
  53.   return obj !== null && typeof obj === 'object'
  54. }
  55.  
  56. /**
  57.  * Get the raw type string of a value e.g. [object Object]
  58.  */
  59. var _toString = Object.prototype.toString;
  60.  
  61. function toRawType (value) {
  62.   return _toString.call(value).slice(8, -1)
  63. }
  64.  
  65. /**
  66.  * Strict object type check. Only returns true
  67.  * for plain JavaScript objects.
  68.  */
  69. function isPlainObject (obj) {
  70.   return _toString.call(obj) === '[object Object]'
  71. }
  72.  
  73. function isRegExp (v) {
  74.   return _toString.call(v) === '[object RegExp]'
  75. }
  76.  
  77. /**
  78.  * Check if val is a valid array index.
  79.  */
  80. function isValidArrayIndex (val) {
  81.   var n = parseFloat(String(val));
  82.   return n >= 0 && Math.floor(n) === n && isFinite(val)
  83. }
  84.  
  85. /**
  86.  * Convert a value to a string that is actually rendered.
  87.  */
  88. function toString (val) {
  89.   return val == null
  90.     ? ''
  91.     : typeof val === 'object'
  92.       ? JSON.stringify(val, null, 2)
  93.       : String(val)
  94. }
  95.  
  96. /**
  97.  * Convert a input value to a number for persistence.
  98.  * If the conversion fails, return original string.
  99.  */
  100. function toNumber (val) {
  101.   var n = parseFloat(val);
  102.   return isNaN(n) ? val : n
  103. }
  104.  
  105. /**
  106.  * Make a map and return a function for checking if a key
  107.  * is in that map.
  108.  */
  109. function makeMap (
  110.   str,
  111.   expectsLowerCase
  112. ) {
  113.   var map = Object.create(null);
  114.   var list = str.split(',');
  115.   for (var i = 0; i < list.length; i++) {
  116.     map[list[i]] = true;
  117.   }
  118.   return expectsLowerCase
  119.     ? function (val) { return map[val.toLowerCase()]; }
  120.     : function (val) { return map[val]; }
  121. }
  122.  
  123. /**
  124.  * Check if a tag is a built-in tag.
  125.  */
  126. var isBuiltInTag = makeMap('slot,component', true);
  127.  
  128. /**
  129.  * Check if a attribute is a reserved attribute.
  130.  */
  131. var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
  132.  
  133. /**
  134.  * Remove an item from an array
  135.  */
  136. function remove (arr, item) {
  137.   if (arr.length) {
  138.     var index = arr.indexOf(item);
  139.     if (index > -1) {
  140.       return arr.splice(index, 1)
  141.     }
  142.   }
  143. }
  144.  
  145. /**
  146.  * Check whether the object has the property.
  147.  */
  148. var hasOwnProperty = Object.prototype.hasOwnProperty;
  149. function hasOwn (obj, key) {
  150.   return hasOwnProperty.call(obj, key)
  151. }
  152.  
  153. /**
  154.  * Create a cached version of a pure function.
  155.  */
  156. function cached (fn) {
  157.   var cache = Object.create(null);
  158.   return (function cachedFn (str) {
  159.     var hit = cache[str];
  160.     return hit || (cache[str] = fn(str))
  161.   })
  162. }
  163.  
  164. /**
  165.  * Camelize a hyphen-delimited string.
  166.  */
  167. var camelizeRE = /-(\w)/g;
  168. var camelize = cached(function (str) {
  169.   return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
  170. });
  171.  
  172. /**
  173.  * Capitalize a string.
  174.  */
  175. var capitalize = cached(function (str) {
  176.   return str.charAt(0).toUpperCase() + str.slice(1)
  177. });
  178.  
  179. /**
  180.  * Hyphenate a camelCase string.
  181.  */
  182. var hyphenateRE = /\B([A-Z])/g;
  183. var hyphenate = cached(function (str) {
  184.   return str.replace(hyphenateRE, '-$1').toLowerCase()
  185. });
  186.  
  187. /**
  188.  * Simple bind, faster than native
  189.  */
  190. function bind (fn, ctx) {
  191.   function boundFn (a) {
  192.     var l = arguments.length;
  193.     return l
  194.       ? l > 1
  195.         ? fn.apply(ctx, arguments)
  196.         : fn.call(ctx, a)
  197.       : fn.call(ctx)
  198.   }
  199.   // record original fn length
  200.   boundFn._length = fn.length;
  201.   return boundFn
  202. }
  203.  
  204. /**
  205.  * Convert an Array-like object to a real Array.
  206.  */
  207. function toArray (list, start) {
  208.   start = start || 0;
  209.   var i = list.length - start;
  210.   var ret = new Array(i);
  211.   while (i--) {
  212.     ret[i] = list[i + start];
  213.   }
  214.   return ret
  215. }
  216.  
  217. /**
  218.  * Mix properties into target object.
  219.  */
  220. function extend (to, _from) {
  221.   for (var key in _from) {
  222.     to[key] = _from[key];
  223.   }
  224.   return to
  225. }
  226.  
  227. /**
  228.  * Merge an Array of Objects into a single Object.
  229.  */
  230. function toObject (arr) {
  231.   var res = {};
  232.   for (var i = 0; i < arr.length; i++) {
  233.     if (arr[i]) {
  234.       extend(res, arr[i]);
  235.     }
  236.   }
  237.   return res
  238. }
  239.  
  240. /**
  241.  * Perform no operation.
  242.  * Stubbing args to make Flow happy without leaving useless transpiled code
  243.  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
  244.  */
  245. function noop (a, b, c) {}
  246.  
  247. /**
  248.  * Always return false.
  249.  */
  250. var no = function (a, b, c) { return false; };
  251.  
  252. /**
  253.  * Return same value
  254.  */
  255. var identity = function (_) { return _; };
  256.  
  257. /**
  258.  * Generate a static keys string from compiler modules.
  259.  */
  260. function genStaticKeys (modules) {
  261.   return modules.reduce(function (keys, m) {
  262.     return keys.concat(m.staticKeys || [])
  263.   }, []).join(',')
  264. }
  265.  
  266. /**
  267.  * Check if two values are loosely equal - that is,
  268.  * if they are plain objects, do they have the same shape?
  269.  */
  270. function looseEqual (a, b) {
  271.   if (a === b) { return true }
  272.   var isObjectA = isObject(a);
  273.   var isObjectB = isObject(b);
  274.   if (isObjectA && isObjectB) {
  275.     try {
  276.       var isArrayA = Array.isArray(a);
  277.       var isArrayB = Array.isArray(b);
  278.       if (isArrayA && isArrayB) {
  279.         return a.length === b.length && a.every(function (e, i) {
  280.           return looseEqual(e, b[i])
  281.         })
  282.       } else if (!isArrayA && !isArrayB) {
  283.         var keysA = Object.keys(a);
  284.         var keysB = Object.keys(b);
  285.         return keysA.length === keysB.length && keysA.every(function (key) {
  286.           return looseEqual(a[key], b[key])
  287.         })
  288.       } else {
  289.         /* istanbul ignore next */
  290.         return false
  291.       }
  292.     } catch (e) {
  293.       /* istanbul ignore next */
  294.       return false
  295.     }
  296.   } else if (!isObjectA && !isObjectB) {
  297.     return String(a) === String(b)
  298.   } else {
  299.     return false
  300.   }
  301. }
  302.  
  303. function looseIndexOf (arr, val) {
  304.   for (var i = 0; i < arr.length; i++) {
  305.     if (looseEqual(arr[i], val)) { return i }
  306.   }
  307.   return -1
  308. }
  309.  
  310. /**
  311.  * Ensure a function is called only once.
  312.  */
  313. function once (fn) {
  314.   var called = false;
  315.   return function () {
  316.     if (!called) {
  317.       called = true;
  318.       fn.apply(this, arguments);
  319.     }
  320.   }
  321. }
  322.  
  323. var SSR_ATTR = 'data-server-rendered';
  324.  
  325. var ASSET_TYPES = [
  326.   'component',
  327.   'directive',
  328.   'filter'
  329. ];
  330.  
  331. var LIFECYCLE_HOOKS = [
  332.   'beforeCreate',
  333.   'created',
  334.   'beforeMount',
  335.   'mounted',
  336.   'beforeUpdate',
  337.   'updated',
  338.   'beforeDestroy',
  339.   'destroyed',
  340.   'activated',
  341.   'deactivated',
  342.   'errorCaptured'
  343. ];
  344.  
  345. /*  */
  346.  
  347. var config = ({
  348.   /**
  349.    * Option merge strategies (used in core/util/options)
  350.    */
  351.   // $flow-disable-line
  352.   optionMergeStrategies: Object.create(null),
  353.  
  354.   /**
  355.    * Whether to suppress warnings.
  356.    */
  357.   silent: false,
  358.  
  359.   /**
  360.    * Show production mode tip message on boot?
  361.    */
  362.   productionTip: "development" !== 'production',
  363.  
  364.   /**
  365.    * Whether to enable devtools
  366.    */
  367.   devtools: "development" !== 'production',
  368.  
  369.   /**
  370.    * Whether to record perf
  371.    */
  372.   performance: false,
  373.  
  374.   /**
  375.    * Error handler for watcher errors
  376.    */
  377.   errorHandler: null,
  378.  
  379.   /**
  380.    * Warn handler for watcher warns
  381.    */
  382.   warnHandler: null,
  383.  
  384.   /**
  385.    * Ignore certain custom elements
  386.    */
  387.   ignoredElements: [],
  388.  
  389.   /**
  390.    * Custom user key aliases for v-on
  391.    */
  392.   // $flow-disable-line
  393.   keyCodes: Object.create(null),
  394.  
  395.   /**
  396.    * Check if a tag is reserved so that it cannot be registered as a
  397.    * component. This is platform-dependent and may be overwritten.
  398.    */
  399.   isReservedTag: no,
  400.  
  401.   /**
  402.    * Check if an attribute is reserved so that it cannot be used as a component
  403.    * prop. This is platform-dependent and may be overwritten.
  404.    */
  405.   isReservedAttr: no,
  406.  
  407.   /**
  408.    * Check if a tag is an unknown element.
  409.    * Platform-dependent.
  410.    */
  411.   isUnknownElement: no,
  412.  
  413.   /**
  414.    * Get the namespace of an element
  415.    */
  416.   getTagNamespace: noop,
  417.  
  418.   /**
  419.    * Parse the real tag name for the specific platform.
  420.    */
  421.   parsePlatformTagName: identity,
  422.  
  423.   /**
  424.    * Check if an attribute must be bound using property, e.g. value
  425.    * Platform-dependent.
  426.    */
  427.   mustUseProp: no,
  428.  
  429.   /**
  430.    * Exposed for legacy reasons
  431.    */
  432.   _lifecycleHooks: LIFECYCLE_HOOKS
  433. });
  434.  
  435. /*  */
  436.  
  437. /**
  438.  * Check if a string starts with $ or _
  439.  */
  440. function isReserved (str) {
  441.   var c = (str + '').charCodeAt(0);
  442.   return c === 0x24 || c === 0x5F
  443. }
  444.  
  445. /**
  446.  * Define a property.
  447.  */
  448. function def (obj, key, val, enumerable) {
  449.   Object.defineProperty(obj, key, {
  450.     value: val,
  451.     enumerable: !!enumerable,
  452.     writable: true,
  453.     configurable: true
  454.   });
  455. }
  456.  
  457. /**
  458.  * Parse simple path.
  459.  */
  460. var bailRE = /[^\w.$]/;
  461. function parsePath (path) {
  462.   if (bailRE.test(path)) {
  463.     return
  464.   }
  465.   var segments = path.split('.');
  466.   return function (obj) {
  467.     for (var i = 0; i < segments.length; i++) {
  468.       if (!obj) { return }
  469.       obj = obj[segments[i]];
  470.     }
  471.     return obj
  472.   }
  473. }
  474.  
  475. /*  */
  476.  
  477.  
  478. // can we use __proto__?
  479. var hasProto = '__proto__' in {};
  480.  
  481. // Browser environment sniffing
  482. var inBrowser = typeof window !== 'undefined';
  483. var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
  484. var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
  485. var UA = inBrowser && window.navigator.userAgent.toLowerCase();
  486. var isIE = UA && /msie|trident/.test(UA);
  487. var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
  488. var isEdge = UA && UA.indexOf('edge/') > 0;
  489. var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
  490. var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
  491. var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
  492.  
  493. // Firefox has a "watch" function on Object.prototype...
  494. var nativeWatch = ({}).watch;
  495.  
  496. var supportsPassive = false;
  497. if (inBrowser) {
  498.   try {
  499.     var opts = {};
  500.     Object.defineProperty(opts, 'passive', ({
  501.       get: function get () {
  502.         /* istanbul ignore next */
  503.         supportsPassive = true;
  504.       }
  505.     })); // https://github.com/facebook/flow/issues/285
  506.     window.addEventListener('test-passive', null, opts);
  507.   } catch (e) {}
  508. }
  509.  
  510. // this needs to be lazy-evaled because vue may be required before
  511. // vue-server-renderer can set VUE_ENV
  512. var _isServer;
  513. var isServerRendering = function () {
  514.   if (_isServer === undefined) {
  515.     /* istanbul ignore if */
  516.     if (!inBrowser && typeof global !== 'undefined') {
  517.       // detect presence of vue-server-renderer and avoid
  518.       // Webpack shimming the process
  519.       _isServer = global['process'].env.VUE_ENV === 'server';
  520.     } else {
  521.       _isServer = false;
  522.     }
  523.   }
  524.   return _isServer
  525. };
  526.  
  527. // detect devtools
  528. var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
  529.  
  530. /* istanbul ignore next */
  531. function isNative (Ctor) {
  532.   return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
  533. }
  534.  
  535. var hasSymbol =
  536.   typeof Symbol !== 'undefined' && isNative(Symbol) &&
  537.   typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
  538.  
  539. var _Set;
  540. /* istanbul ignore if */ // $flow-disable-line
  541. if (typeof Set !== 'undefined' && isNative(Set)) {
  542.   // use native Set when available.
  543.   _Set = Set;
  544. } else {
  545.   // a non-standard Set polyfill that only works with primitive keys.
  546.   _Set = (function () {
  547.     function Set () {
  548.       this.set = Object.create(null);
  549.     }
  550.     Set.prototype.has = function has (key) {
  551.       return this.set[key] === true
  552.     };
  553.     Set.prototype.add = function add (key) {
  554.       this.set[key] = true;
  555.     };
  556.     Set.prototype.clear = function clear () {
  557.       this.set = Object.create(null);
  558.     };
  559.  
  560.     return Set;
  561.   }());
  562. }
  563.  
  564. /*  */
  565.  
  566. var warn = noop;
  567. var tip = noop;
  568. var generateComponentTrace = (noop); // work around flow check
  569. var formatComponentName = (noop);
  570.  
  571. {
  572.   var hasConsole = typeof console !== 'undefined';
  573.   var classifyRE = /(?:^|[-_])(\w)/g;
  574.   var classify = function (str) { return str
  575.     .replace(classifyRE, function (c) { return c.toUpperCase(); })
  576.     .replace(/[-_]/g, ''); };
  577.  
  578.   warn = function (msg, vm) {
  579.     var trace = vm ? generateComponentTrace(vm) : '';
  580.  
  581.     if (config.warnHandler) {
  582.       config.warnHandler.call(null, msg, vm, trace);
  583.     } else if (hasConsole && (!config.silent)) {
  584.       console.error(("[Vue warn]: " + msg + trace));
  585.     }
  586.   };
  587.  
  588.   tip = function (msg, vm) {
  589.     if (hasConsole && (!config.silent)) {
  590.       console.warn("[Vue tip]: " + msg + (
  591.         vm ? generateComponentTrace(vm) : ''
  592.       ));
  593.     }
  594.   };
  595.  
  596.   formatComponentName = function (vm, includeFile) {
  597.     if (vm.$root === vm) {
  598.       return '<Root>'
  599.     }
  600.     var options = typeof vm === 'function' && vm.cid != null
  601.       ? vm.options
  602.       : vm._isVue
  603.         ? vm.$options || vm.constructor.options
  604.         : vm || {};
  605.     var name = options.name || options._componentTag;
  606.     var file = options.__file;
  607.     if (!name && file) {
  608.       var match = file.match(/([^/\\]+)\.vue$/);
  609.       name = match && match[1];
  610.     }
  611.  
  612.     return (
  613.       (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
  614.       (file && includeFile !== false ? (" at " + file) : '')
  615.     )
  616.   };
  617.  
  618.   var repeat = function (str, n) {
  619.     var res = '';
  620.     while (n) {
  621.       if (n % 2 === 1) { res += str; }
  622.       if (n > 1) { str += str; }
  623.       n >>= 1;
  624.     }
  625.     return res
  626.   };
  627.  
  628.   generateComponentTrace = function (vm) {
  629.     if (vm._isVue && vm.$parent) {
  630.       var tree = [];
  631.       var currentRecursiveSequence = 0;
  632.       while (vm) {
  633.         if (tree.length > 0) {
  634.           var last = tree[tree.length - 1];
  635.           if (last.constructor === vm.constructor) {
  636.             currentRecursiveSequence++;
  637.             vm = vm.$parent;
  638.             continue
  639.           } else if (currentRecursiveSequence > 0) {
  640.             tree[tree.length - 1] = [last, currentRecursiveSequence];
  641.             currentRecursiveSequence = 0;
  642.           }
  643.         }
  644.         tree.push(vm);
  645.         vm = vm.$parent;
  646.       }
  647.       return '\n\nfound in\n\n' + tree
  648.         .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
  649.             ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
  650.             : formatComponentName(vm))); })
  651.         .join('\n')
  652.     } else {
  653.       return ("\n\n(found in " + (formatComponentName(vm)) + ")")
  654.     }
  655.   };
  656. }
  657.  
  658. /*  */
  659.  
  660.  
  661. var uid = 0;
  662.  
  663. /**
  664.  * A dep is an observable that can have multiple
  665.  * directives subscribing to it.
  666.  */
  667. var Dep = function Dep () {
  668.   this.id = uid++;
  669.   this.subs = [];
  670. };
  671.  
  672. Dep.prototype.addSub = function addSub (sub) {
  673.   this.subs.push(sub);
  674. };
  675.  
  676. Dep.prototype.removeSub = function removeSub (sub) {
  677.   remove(this.subs, sub);
  678. };
  679.  
  680. Dep.prototype.depend = function depend () {
  681.   if (Dep.target) {
  682.     Dep.target.addDep(this);
  683.   }
  684. };
  685.  
  686. Dep.prototype.notify = function notify () {
  687.   // stabilize the subscriber list first
  688.   var subs = this.subs.slice();
  689.   for (var i = 0, l = subs.length; i < l; i++) {
  690.     subs[i].update();
  691.   }
  692. };
  693.  
  694. // the current target watcher being evaluated.
  695. // this is globally unique because there could be only one
  696. // watcher being evaluated at any time.
  697. Dep.target = null;
  698. var targetStack = [];
  699.  
  700. function pushTarget (_target) {
  701.   if (Dep.target) { targetStack.push(Dep.target); }
  702.   Dep.target = _target;
  703. }
  704.  
  705. function popTarget () {
  706.   Dep.target = targetStack.pop();
  707. }
  708.  
  709. /*  */
  710.  
  711. var VNode = function VNode (
  712.   tag,
  713.   data,
  714.   children,
  715.   text,
  716.   elm,
  717.   context,
  718.   componentOptions,
  719.   asyncFactory
  720. ) {
  721.   this.tag = tag;
  722.   this.data = data;
  723.   this.children = children;
  724.   this.text = text;
  725.   this.elm = elm;
  726.   this.ns = undefined;
  727.   this.context = context;
  728.   this.fnContext = undefined;
  729.   this.fnOptions = undefined;
  730.   this.fnScopeId = undefined;
  731.   this.key = data && data.key;
  732.   this.componentOptions = componentOptions;
  733.   this.componentInstance = undefined;
  734.   this.parent = undefined;
  735.   this.raw = false;
  736.   this.isStatic = false;
  737.   this.isRootInsert = true;
  738.   this.isComment = false;
  739.   this.isCloned = false;
  740.   this.isOnce = false;
  741.   this.asyncFactory = asyncFactory;
  742.   this.asyncMeta = undefined;
  743.   this.isAsyncPlaceholder = false;
  744. };
  745.  
  746. var prototypeAccessors = { child: { configurable: true } };
  747.  
  748. // DEPRECATED: alias for componentInstance for backwards compat.
  749. /* istanbul ignore next */
  750. prototypeAccessors.child.get = function () {
  751.   return this.componentInstance
  752. };
  753.  
  754. Object.defineProperties( VNode.prototype, prototypeAccessors );
  755.  
  756. var createEmptyVNode = function (text) {
  757.   if ( text === void 0 ) text = '';
  758.  
  759.   var node = new VNode();
  760.   node.text = text;
  761.   node.isComment = true;
  762.   return node
  763. };
  764.  
  765. function createTextVNode (val) {
  766.   return new VNode(undefined, undefined, undefined, String(val))
  767. }
  768.  
  769. // optimized shallow clone
  770. // used for static nodes and slot nodes because they may be reused across
  771. // multiple renders, cloning them avoids errors when DOM manipulations rely
  772. // on their elm reference.
  773. function cloneVNode (vnode, deep) {
  774.   var componentOptions = vnode.componentOptions;
  775.   var cloned = new VNode(
  776.     vnode.tag,
  777.     vnode.data,
  778.     vnode.children,
  779.     vnode.text,
  780.     vnode.elm,
  781.     vnode.context,
  782.     componentOptions,
  783.     vnode.asyncFactory
  784.   );
  785.   cloned.ns = vnode.ns;
  786.   cloned.isStatic = vnode.isStatic;
  787.   cloned.key = vnode.key;
  788.   cloned.isComment = vnode.isComment;
  789.   cloned.fnContext = vnode.fnContext;
  790.   cloned.fnOptions = vnode.fnOptions;
  791.   cloned.fnScopeId = vnode.fnScopeId;
  792.   cloned.isCloned = true;
  793.   if (deep) {
  794.     if (vnode.children) {
  795.       cloned.children = cloneVNodes(vnode.children, true);
  796.     }
  797.     if (componentOptions && componentOptions.children) {
  798.       componentOptions.children = cloneVNodes(componentOptions.children, true);
  799.     }
  800.   }
  801.   return cloned
  802. }
  803.  
  804. function cloneVNodes (vnodes, deep) {
  805.   var len = vnodes.length;
  806.   var res = new Array(len);
  807.   for (var i = 0; i < len; i++) {
  808.     res[i] = cloneVNode(vnodes[i], deep);
  809.   }
  810.   return res
  811. }
  812.  
  813. /*
  814.  * not type checking this file because flow doesn't play well with
  815.  * dynamically accessing methods on Array prototype
  816.  */
  817.  
  818. var arrayProto = Array.prototype;
  819. var arrayMethods = Object.create(arrayProto);[
  820.   'push',
  821.   'pop',
  822.   'shift',
  823.   'unshift',
  824.   'splice',
  825.   'sort',
  826.   'reverse'
  827. ].forEach(function (method) {
  828.   // cache original method
  829.   var original = arrayProto[method];
  830.   def(arrayMethods, method, function mutator () {
  831.     var args = [], len = arguments.length;
  832.     while ( len-- ) args[ len ] = arguments[ len ];
  833.  
  834.     var result = original.apply(this, args);
  835.     var ob = this.__ob__;
  836.     var inserted;
  837.     switch (method) {
  838.       case 'push':
  839.       case 'unshift':
  840.         inserted = args;
  841.         break
  842.       case 'splice':
  843.         inserted = args.slice(2);
  844.         break
  845.     }
  846.     if (inserted) { ob.observeArray(inserted); }
  847.     // notify change
  848.     ob.dep.notify();
  849.     return result
  850.   });
  851. });
  852.  
  853. /*  */
  854.  
  855. var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
  856.  
  857. /**
  858.  * By default, when a reactive property is set, the new value is
  859.  * also converted to become reactive. However when passing down props,
  860.  * we don't want to force conversion because the value may be a nested value
  861.  * under a frozen data structure. Converting it would defeat the optimization.
  862.  */
  863. var observerState = {
  864.   shouldConvert: true
  865. };
  866.  
  867. /**
  868.  * Observer class that are attached to each observed
  869.  * object. Once attached, the observer converts target
  870.  * object's property keys into getter/setters that
  871.  * collect dependencies and dispatches updates.
  872.  */
  873. var Observer = function Observer (value) {
  874.   this.value = value;
  875.   this.dep = new Dep();
  876.   this.vmCount = 0;
  877.   def(value, '__ob__', this);
  878.   if (Array.isArray(value)) {
  879.     var augment = hasProto
  880.       ? protoAugment
  881.       : copyAugment;
  882.     augment(value, arrayMethods, arrayKeys);
  883.     this.observeArray(value);
  884.   } else {
  885.     this.walk(value);
  886.   }
  887. };
  888.  
  889. /**
  890.  * Walk through each property and convert them into
  891.  * getter/setters. This method should only be called when
  892.  * value type is Object.
  893.  */
  894. Observer.prototype.walk = function walk (obj) {
  895.   var keys = Object.keys(obj);
  896.   for (var i = 0; i < keys.length; i++) {
  897.     defineReactive(obj, keys[i], obj[keys[i]]);
  898.   }
  899. };
  900.  
  901. /**
  902.  * Observe a list of Array items.
  903.  */
  904. Observer.prototype.observeArray = function observeArray (items) {
  905.   for (var i = 0, l = items.length; i < l; i++) {
  906.     observe(items[i]);
  907.   }
  908. };
  909.  
  910. // helpers
  911.  
  912. /**
  913.  * Augment an target Object or Array by intercepting
  914.  * the prototype chain using __proto__
  915.  */
  916. function protoAugment (target, src, keys) {
  917.   /* eslint-disable no-proto */
  918.   target.__proto__ = src;
  919.   /* eslint-enable no-proto */
  920. }
  921.  
  922. /**
  923.  * Augment an target Object or Array by defining
  924.  * hidden properties.
  925.  */
  926. /* istanbul ignore next */
  927. function copyAugment (target, src, keys) {
  928.   for (var i = 0, l = keys.length; i < l; i++) {
  929.     var key = keys[i];
  930.     def(target, key, src[key]);
  931.   }
  932. }
  933.  
  934. /**
  935.  * Attempt to create an observer instance for a value,
  936.  * returns the new observer if successfully observed,
  937.  * or the existing observer if the value already has one.
  938.  */
  939. function observe (value, asRootData) {
  940.   if (!isObject(value) || value instanceof VNode) {
  941.     return
  942.   }
  943.   var ob;
  944.   if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
  945.     ob = value.__ob__;
  946.   } else if (
  947.     observerState.shouldConvert &&
  948.     !isServerRendering() &&
  949.     (Array.isArray(value) || isPlainObject(value)) &&
  950.     Object.isExtensible(value) &&
  951.     !value._isVue
  952.   ) {
  953.     ob = new Observer(value);
  954.   }
  955.   if (asRootData && ob) {
  956.     ob.vmCount++;
  957.   }
  958.   return ob
  959. }
  960.  
  961. /**
  962.  * Define a reactive property on an Object.
  963.  */
  964. function defineReactive (
  965.   obj,
  966.   key,
  967.   val,
  968.   customSetter,
  969.   shallow
  970. ) {
  971.   var dep = new Dep();
  972.  
  973.   var property = Object.getOwnPropertyDescriptor(obj, key);
  974.   if (property && property.configurable === false) {
  975.     return
  976.   }
  977.  
  978.   // cater for pre-defined getter/setters
  979.   var getter = property && property.get;
  980.   var setter = property && property.set;
  981.  
  982.   var childOb = !shallow && observe(val);
  983.   Object.defineProperty(obj, key, {
  984.     enumerable: true,
  985.     configurable: true,
  986.     get: function reactiveGetter () {
  987.       var value = getter ? getter.call(obj) : val;
  988.       if (Dep.target) {
  989.         dep.depend();
  990.         if (childOb) {
  991.           childOb.dep.depend();
  992.           if (Array.isArray(value)) {
  993.             dependArray(value);
  994.           }
  995.         }
  996.       }
  997.       return value
  998.     },
  999.     set: function reactiveSetter (newVal) {
  1000.       var value = getter ? getter.call(obj) : val;
  1001.       /* eslint-disable no-self-compare */
  1002.       if (newVal === value || (newVal !== newVal && value !== value)) {
  1003.         return
  1004.       }
  1005.       /* eslint-enable no-self-compare */
  1006.       if ("development" !== 'production' && customSetter) {
  1007.         customSetter();
  1008.       }
  1009.       if (setter) {
  1010.         setter.call(obj, newVal);
  1011.       } else {
  1012.         val = newVal;
  1013.       }
  1014.       childOb = !shallow && observe(newVal);
  1015.       dep.notify();
  1016.     }
  1017.   });
  1018. }
  1019.  
  1020. /**
  1021.  * Set a property on an object. Adds the new property and
  1022.  * triggers change notification if the property doesn't
  1023.  * already exist.
  1024.  */
  1025. function set (target, key, val) {
  1026.   if (Array.isArray(target) && isValidArrayIndex(key)) {
  1027.     target.length = Math.max(target.length, key);
  1028.     target.splice(key, 1, val);
  1029.     return val
  1030.   }
  1031.   if (key in target && !(key in Object.prototype)) {
  1032.     target[key] = val;
  1033.     return val
  1034.   }
  1035.   var ob = (target).__ob__;
  1036.   if (target._isVue || (ob && ob.vmCount)) {
  1037.     "development" !== 'production' && warn(
  1038.       'Avoid adding reactive properties to a Vue instance or its root $data ' +
  1039.       'at runtime - declare it upfront in the data option.'
  1040.     );
  1041.     return val
  1042.   }
  1043.   if (!ob) {
  1044.     target[key] = val;
  1045.     return val
  1046.   }
  1047.   defineReactive(ob.value, key, val);
  1048.   ob.dep.notify();
  1049.   return val
  1050. }
  1051.  
  1052. /**
  1053.  * Delete a property and trigger change if necessary.
  1054.  */
  1055. function del (target, key) {
  1056.   if (Array.isArray(target) && isValidArrayIndex(key)) {
  1057.     target.splice(key, 1);
  1058.     return
  1059.   }
  1060.   var ob = (target).__ob__;
  1061.   if (target._isVue || (ob && ob.vmCount)) {
  1062.     "development" !== 'production' && warn(
  1063.       'Avoid deleting properties on a Vue instance or its root $data ' +
  1064.       '- just set it to null.'
  1065.     );
  1066.     return
  1067.   }
  1068.   if (!hasOwn(target, key)) {
  1069.     return
  1070.   }
  1071.   delete target[key];
  1072.   if (!ob) {
  1073.     return
  1074.   }
  1075.   ob.dep.notify();
  1076. }
  1077.  
  1078. /**
  1079.  * Collect dependencies on array elements when the array is touched, since
  1080.  * we cannot intercept array element access like property getters.
  1081.  */
  1082. function dependArray (value) {
  1083.   for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
  1084.     e = value[i];
  1085.     e && e.__ob__ && e.__ob__.dep.depend();
  1086.     if (Array.isArray(e)) {
  1087.       dependArray(e);
  1088.     }
  1089.   }
  1090. }
  1091.  
  1092. /*  */
  1093.  
  1094. /**
  1095.  * Option overwriting strategies are functions that handle
  1096.  * how to merge a parent option value and a child option
  1097.  * value into the final value.
  1098.  */
  1099. var strats = config.optionMergeStrategies;
  1100.  
  1101. /**
  1102.  * Options with restrictions
  1103.  */
  1104. {
  1105.   strats.el = strats.propsData = function (parent, child, vm, key) {
  1106.     if (!vm) {
  1107.       warn(
  1108.         "option \"" + key + "\" can only be used during instance " +
  1109.         'creation with the `new` keyword.'
  1110.       );
  1111.     }
  1112.     return defaultStrat(parent, child)
  1113.   };
  1114. }
  1115.  
  1116. /**
  1117.  * Helper that recursively merges two data objects together.
  1118.  */
  1119. function mergeData (to, from) {
  1120.   if (!from) { return to }
  1121.   var key, toVal, fromVal;
  1122.   var keys = Object.keys(from);
  1123.   for (var i = 0; i < keys.length; i++) {
  1124.     key = keys[i];
  1125.     toVal = to[key];
  1126.     fromVal = from[key];
  1127.     if (!hasOwn(to, key)) {
  1128.       set(to, key, fromVal);
  1129.     } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
  1130.       mergeData(toVal, fromVal);
  1131.     }
  1132.   }
  1133.   return to
  1134. }
  1135.  
  1136. /**
  1137.  * Data
  1138.  */
  1139. function mergeDataOrFn (
  1140.   parentVal,
  1141.   childVal,
  1142.   vm
  1143. ) {
  1144.   if (!vm) {
  1145.     // in a Vue.extend merge, both should be functions
  1146.     if (!childVal) {
  1147.       return parentVal
  1148.     }
  1149.     if (!parentVal) {
  1150.       return childVal
  1151.     }
  1152.     // when parentVal & childVal are both present,
  1153.     // we need to return a function that returns the
  1154.     // merged result of both functions... no need to
  1155.     // check if parentVal is a function here because
  1156.     // it has to be a function to pass previous merges.
  1157.     return function mergedDataFn () {
  1158.       return mergeData(
  1159.         typeof childVal === 'function' ? childVal.call(this, this) : childVal,
  1160.         typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
  1161.       )
  1162.     }
  1163.   } else {
  1164.     return function mergedInstanceDataFn () {
  1165.       // instance merge
  1166.       var instanceData = typeof childVal === 'function'
  1167.         ? childVal.call(vm, vm)
  1168.         : childVal;
  1169.       var defaultData = typeof parentVal === 'function'
  1170.         ? parentVal.call(vm, vm)
  1171.         : parentVal;
  1172.       if (instanceData) {
  1173.         return mergeData(instanceData, defaultData)
  1174.       } else {
  1175.         return defaultData
  1176.       }
  1177.     }
  1178.   }
  1179. }
  1180.  
  1181. strats.data = function (
  1182.   parentVal,
  1183.   childVal,
  1184.   vm
  1185. ) {
  1186.   if (!vm) {
  1187.     if (childVal && typeof childVal !== 'function') {
  1188.       "development" !== 'production' && warn(
  1189.         'The "data" option should be a function ' +
  1190.         'that returns a per-instance value in component ' +
  1191.         'definitions.',
  1192.         vm
  1193.       );
  1194.  
  1195.       return parentVal
  1196.     }
  1197.     return mergeDataOrFn(parentVal, childVal)
  1198.   }
  1199.  
  1200.   return mergeDataOrFn(parentVal, childVal, vm)
  1201. };
  1202.  
  1203. /**
  1204.  * Hooks and props are merged as arrays.
  1205.  */
  1206. function mergeHook (
  1207.   parentVal,
  1208.   childVal
  1209. ) {
  1210.   return childVal
  1211.     ? parentVal
  1212.       ? parentVal.concat(childVal)
  1213.       : Array.isArray(childVal)
  1214.         ? childVal
  1215.         : [childVal]
  1216.     : parentVal
  1217. }
  1218.  
  1219. LIFECYCLE_HOOKS.forEach(function (hook) {
  1220.   strats[hook] = mergeHook;
  1221. });
  1222.  
  1223. /**
  1224.  * Assets
  1225.  *
  1226.  * When a vm is present (instance creation), we need to do
  1227.  * a three-way merge between constructor options, instance
  1228.  * options and parent options.
  1229.  */
  1230. function mergeAssets (
  1231.   parentVal,
  1232.   childVal,
  1233.   vm,
  1234.   key
  1235. ) {
  1236.   var res = Object.create(parentVal || null);
  1237.   if (childVal) {
  1238.     "development" !== 'production' && assertObjectType(key, childVal, vm);
  1239.     return extend(res, childVal)
  1240.   } else {
  1241.     return res
  1242.   }
  1243. }
  1244.  
  1245. ASSET_TYPES.forEach(function (type) {
  1246.   strats[type + 's'] = mergeAssets;
  1247. });
  1248.  
  1249. /**
  1250.  * Watchers.
  1251.  *
  1252.  * Watchers hashes should not overwrite one
  1253.  * another, so we merge them as arrays.
  1254.  */
  1255. strats.watch = function (
  1256.   parentVal,
  1257.   childVal,
  1258.   vm,
  1259.   key
  1260. ) {
  1261.   // work around Firefox's Object.prototype.watch...
  1262.   if (parentVal === nativeWatch) { parentVal = undefined; }
  1263.   if (childVal === nativeWatch) { childVal = undefined; }
  1264.   /* istanbul ignore if */
  1265.   if (!childVal) { return Object.create(parentVal || null) }
  1266.   {
  1267.     assertObjectType(key, childVal, vm);
  1268.   }
  1269.   if (!parentVal) { return childVal }
  1270.   var ret = {};
  1271.   extend(ret, parentVal);
  1272.   for (var key$1 in childVal) {
  1273.     var parent = ret[key$1];
  1274.     var child = childVal[key$1];
  1275.     if (parent && !Array.isArray(parent)) {
  1276.       parent = [parent];
  1277.     }
  1278.     ret[key$1] = parent
  1279.       ? parent.concat(child)
  1280.       : Array.isArray(child) ? child : [child];
  1281.   }
  1282.   return ret
  1283. };
  1284.  
  1285. /**
  1286.  * Other object hashes.
  1287.  */
  1288. strats.props =
  1289. strats.methods =
  1290. strats.inject =
  1291. strats.computed = function (
  1292.   parentVal,
  1293.   childVal,
  1294.   vm,
  1295.   key
  1296. ) {
  1297.   if (childVal && "development" !== 'production') {
  1298.     assertObjectType(key, childVal, vm);
  1299.   }
  1300.   if (!parentVal) { return childVal }
  1301.   var ret = Object.create(null);
  1302.   extend(ret, parentVal);
  1303.   if (childVal) { extend(ret, childVal); }
  1304.   return ret
  1305. };
  1306. strats.provide = mergeDataOrFn;
  1307.  
  1308. /**
  1309.  * Default strategy.
  1310.  */
  1311. var defaultStrat = function (parentVal, childVal) {
  1312.   return childVal === undefined
  1313.     ? parentVal
  1314.     : childVal
  1315. };
  1316.  
  1317. /**
  1318.  * Validate component names
  1319.  */
  1320. function checkComponents (options) {
  1321.   for (var key in options.components) {
  1322.     validateComponentName(key);
  1323.   }
  1324. }
  1325.  
  1326. function validateComponentName (name) {
  1327.   if (!/^[a-zA-Z][\w-]*$/.test(name)) {
  1328.     warn(
  1329.       'Invalid component name: "' + name + '". Component names ' +
  1330.       'can only contain alphanumeric characters and the hyphen, ' +
  1331.       'and must start with a letter.'
  1332.     );
  1333.   }
  1334.   if (isBuiltInTag(name) || config.isReservedTag(name)) {
  1335.     warn(
  1336.       'Do not use built-in or reserved HTML elements as component ' +
  1337.       'id: ' + name
  1338.     );
  1339.   }
  1340. }
  1341.  
  1342. /**
  1343.  * Ensure all props option syntax are normalized into the
  1344.  * Object-based format.
  1345.  */
  1346. function normalizeProps (options, vm) {
  1347.   var props = options.props;
  1348.   if (!props) { return }
  1349.   var res = {};
  1350.   var i, val, name;
  1351.   if (Array.isArray(props)) {
  1352.     i = props.length;
  1353.     while (i--) {
  1354.       val = props[i];
  1355.       if (typeof val === 'string') {
  1356.         name = camelize(val);
  1357.         res[name] = { type: null };
  1358.       } else {
  1359.         warn('props must be strings when using array syntax.');
  1360.       }
  1361.     }
  1362.   } else if (isPlainObject(props)) {
  1363.     for (var key in props) {
  1364.       val = props[key];
  1365.       name = camelize(key);
  1366.       res[name] = isPlainObject(val)
  1367.         ? val
  1368.         : { type: val };
  1369.     }
  1370.   } else {
  1371.     warn(
  1372.       "Invalid value for option \"props\": expected an Array or an Object, " +
  1373.       "but got " + (toRawType(props)) + ".",
  1374.       vm
  1375.     );
  1376.   }
  1377.   options.props = res;
  1378. }
  1379.  
  1380. /**
  1381.  * Normalize all injections into Object-based format
  1382.  */
  1383. function normalizeInject (options, vm) {
  1384.   var inject = options.inject;
  1385.   if (!inject) { return }
  1386.   var normalized = options.inject = {};
  1387.   if (Array.isArray(inject)) {
  1388.     for (var i = 0; i < inject.length; i++) {
  1389.       normalized[inject[i]] = { from: inject[i] };
  1390.     }
  1391.   } else if (isPlainObject(inject)) {
  1392.     for (var key in inject) {
  1393.       var val = inject[key];
  1394.       normalized[key] = isPlainObject(val)
  1395.         ? extend({ from: key }, val)
  1396.         : { from: val };
  1397.     }
  1398.   } else {
  1399.     warn(
  1400.       "Invalid value for option \"inject\": expected an Array or an Object, " +
  1401.       "but got " + (toRawType(inject)) + ".",
  1402.       vm
  1403.     );
  1404.   }
  1405. }
  1406.  
  1407. /**
  1408.  * Normalize raw function directives into object format.
  1409.  */
  1410. function normalizeDirectives (options) {
  1411.   var dirs = options.directives;
  1412.   if (dirs) {
  1413.     for (var key in dirs) {
  1414.       var def = dirs[key];
  1415.       if (typeof def === 'function') {
  1416.         dirs[key] = { bind: def, update: def };
  1417.       }
  1418.     }
  1419.   }
  1420. }
  1421.  
  1422. function assertObjectType (name, value, vm) {
  1423.   if (!isPlainObject(value)) {
  1424.     warn(
  1425.       "Invalid value for option \"" + name + "\": expected an Object, " +
  1426.       "but got " + (toRawType(value)) + ".",
  1427.       vm
  1428.     );
  1429.   }
  1430. }
  1431.  
  1432. /**
  1433.  * Merge two option objects into a new one.
  1434.  * Core utility used in both instantiation and inheritance.
  1435.  */
  1436. function mergeOptions (
  1437.   parent,
  1438.   child,
  1439.   vm
  1440. ) {
  1441.   {
  1442.     checkComponents(child);
  1443.   }
  1444.  
  1445.   if (typeof child === 'function') {
  1446.     child = child.options;
  1447.   }
  1448.  
  1449.   normalizeProps(child, vm);
  1450.   normalizeInject(child, vm);
  1451.   normalizeDirectives(child);
  1452.   var extendsFrom = child.extends;
  1453.   if (extendsFrom) {
  1454.     parent = mergeOptions(parent, extendsFrom, vm);
  1455.   }
  1456.   if (child.mixins) {
  1457.     for (var i = 0, l = child.mixins.length; i < l; i++) {
  1458.       parent = mergeOptions(parent, child.mixins[i], vm);
  1459.     }
  1460.   }
  1461.   var options = {};
  1462.   var key;
  1463.   for (key in parent) {
  1464.     mergeField(key);
  1465.   }
  1466.   for (key in child) {
  1467.     if (!hasOwn(parent, key)) {
  1468.       mergeField(key);
  1469.     }
  1470.   }
  1471.   function mergeField (key) {
  1472.     var strat = strats[key] || defaultStrat;
  1473.     options[key] = strat(parent[key], child[key], vm, key);
  1474.   }
  1475.   return options
  1476. }
  1477.  
  1478. /**
  1479.  * Resolve an asset.
  1480.  * This function is used because child instances need access
  1481.  * to assets defined in its ancestor chain.
  1482.  */
  1483. function resolveAsset (
  1484.   options,
  1485.   type,
  1486.   id,
  1487.   warnMissing
  1488. ) {
  1489.   /* istanbul ignore if */
  1490.   if (typeof id !== 'string') {
  1491.     return
  1492.   }
  1493.   var assets = options[type];
  1494.   // check local registration variations first
  1495.   if (hasOwn(assets, id)) { return assets[id] }
  1496.   var camelizedId = camelize(id);
  1497.   if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
  1498.   var PascalCaseId = capitalize(camelizedId);
  1499.   if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
  1500.   // fallback to prototype chain
  1501.   var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
  1502.   if ("development" !== 'production' && warnMissing && !res) {
  1503.     warn(
  1504.       'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
  1505.       options
  1506.     );
  1507.   }
  1508.   return res
  1509. }
  1510.  
  1511. /*  */
  1512.  
  1513. function validateProp (
  1514.   key,
  1515.   propOptions,
  1516.   propsData,
  1517.   vm
  1518. ) {
  1519.   var prop = propOptions[key];
  1520.   var absent = !hasOwn(propsData, key);
  1521.   var value = propsData[key];
  1522.   // handle boolean props
  1523.   if (isType(Boolean, prop.type)) {
  1524.     if (absent && !hasOwn(prop, 'default')) {
  1525.       value = false;
  1526.     } else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
  1527.       value = true;
  1528.     }
  1529.   }
  1530.   // check default value
  1531.   if (value === undefined) {
  1532.     value = getPropDefaultValue(vm, prop, key);
  1533.     // since the default value is a fresh copy,
  1534.     // make sure to observe it.
  1535.     var prevShouldConvert = observerState.shouldConvert;
  1536.     observerState.shouldConvert = true;
  1537.     observe(value);
  1538.     observerState.shouldConvert = prevShouldConvert;
  1539.   }
  1540.   {
  1541.     assertProp(prop, key, value, vm, absent);
  1542.   }
  1543.   return value
  1544. }
  1545.  
  1546. /**
  1547.  * Get the default value of a prop.
  1548.  */
  1549. function getPropDefaultValue (vm, prop, key) {
  1550.   // no default, return undefined
  1551.   if (!hasOwn(prop, 'default')) {
  1552.     return undefined
  1553.   }
  1554.   var def = prop.default;
  1555.   // warn against non-factory defaults for Object & Array
  1556.   if ("development" !== 'production' && isObject(def)) {
  1557.     warn(
  1558.       'Invalid default value for prop "' + key + '": ' +
  1559.       'Props with type Object/Array must use a factory function ' +
  1560.       'to return the default value.',
  1561.       vm
  1562.     );
  1563.   }
  1564.   // the raw prop value was also undefined from previous render,
  1565.   // return previous default value to avoid unnecessary watcher trigger
  1566.   if (vm && vm.$options.propsData &&
  1567.     vm.$options.propsData[key] === undefined &&
  1568.     vm._props[key] !== undefined
  1569.   ) {
  1570.     return vm._props[key]
  1571.   }
  1572.   // call factory function for non-Function types
  1573.   // a value is Function if its prototype is function even across different execution context
  1574.   return typeof def === 'function' && getType(prop.type) !== 'Function'
  1575.     ? def.call(vm)
  1576.     : def
  1577. }
  1578.  
  1579. /**
  1580.  * Assert whether a prop is valid.
  1581.  */
  1582. function assertProp (
  1583.   prop,
  1584.   name,
  1585.   value,
  1586.   vm,
  1587.   absent
  1588. ) {
  1589.   if (prop.required && absent) {
  1590.     warn(
  1591.       'Missing required prop: "' + name + '"',
  1592.       vm
  1593.     );
  1594.     return
  1595.   }
  1596.   if (value == null && !prop.required) {
  1597.     return
  1598.   }
  1599.   var type = prop.type;
  1600.   var valid = !type || type === true;
  1601.   var expectedTypes = [];
  1602.   if (type) {
  1603.     if (!Array.isArray(type)) {
  1604.       type = [type];
  1605.     }
  1606.     for (var i = 0; i < type.length && !valid; i++) {
  1607.       var assertedType = assertType(value, type[i]);
  1608.       expectedTypes.push(assertedType.expectedType || '');
  1609.       valid = assertedType.valid;
  1610.     }
  1611.   }
  1612.   if (!valid) {
  1613.     warn(
  1614.       "Invalid prop: type check failed for prop \"" + name + "\"." +
  1615.       " Expected " + (expectedTypes.map(capitalize).join(', ')) +
  1616.       ", got " + (toRawType(value)) + ".",
  1617.       vm
  1618.     );
  1619.     return
  1620.   }
  1621.   var validator = prop.validator;
  1622.   if (validator) {
  1623.     if (!validator(value)) {
  1624.       warn(
  1625.         'Invalid prop: custom validator check failed for prop "' + name + '".',
  1626.         vm
  1627.       );
  1628.     }
  1629.   }
  1630. }
  1631.  
  1632. var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
  1633.  
  1634. function assertType (value, type) {
  1635.   var valid;
  1636.   var expectedType = getType(type);
  1637.   if (simpleCheckRE.test(expectedType)) {
  1638.     var t = typeof value;
  1639.     valid = t === expectedType.toLowerCase();
  1640.     // for primitive wrapper objects
  1641.     if (!valid && t === 'object') {
  1642.       valid = value instanceof type;
  1643.     }
  1644.   } else if (expectedType === 'Object') {
  1645.     valid = isPlainObject(value);
  1646.   } else if (expectedType === 'Array') {
  1647.     valid = Array.isArray(value);
  1648.   } else {
  1649.     valid = value instanceof type;
  1650.   }
  1651.   return {
  1652.     valid: valid,
  1653.     expectedType: expectedType
  1654.   }
  1655. }
  1656.  
  1657. /**
  1658.  * Use function string name to check built-in types,
  1659.  * because a simple equality check will fail when running
  1660.  * across different vms / iframes.
  1661.  */
  1662. function getType (fn) {
  1663.   var match = fn && fn.toString().match(/^\s*function (\w+)/);
  1664.   return match ? match[1] : ''
  1665. }
  1666.  
  1667. function isType (type, fn) {
  1668.   if (!Array.isArray(fn)) {
  1669.     return getType(fn) === getType(type)
  1670.   }
  1671.   for (var i = 0, len = fn.length; i < len; i++) {
  1672.     if (getType(fn[i]) === getType(type)) {
  1673.       return true
  1674.     }
  1675.   }
  1676.   /* istanbul ignore next */
  1677.   return false
  1678. }
  1679.  
  1680. /*  */
  1681.  
  1682. function handleError (err, vm, info) {
  1683.   if (vm) {
  1684.     var cur = vm;
  1685.     while ((cur = cur.$parent)) {
  1686.       var hooks = cur.$options.errorCaptured;
  1687.       if (hooks) {
  1688.         for (var i = 0; i < hooks.length; i++) {
  1689.           try {
  1690.             var capture = hooks[i].call(cur, err, vm, info) === false;
  1691.             if (capture) { return }
  1692.           } catch (e) {
  1693.             globalHandleError(e, cur, 'errorCaptured hook');
  1694.           }
  1695.         }
  1696.       }
  1697.     }
  1698.   }
  1699.   globalHandleError(err, vm, info);
  1700. }
  1701.  
  1702. function globalHandleError (err, vm, info) {
  1703.   if (config.errorHandler) {
  1704.     try {
  1705.       return config.errorHandler.call(null, err, vm, info)
  1706.     } catch (e) {
  1707.       logError(e, null, 'config.errorHandler');
  1708.     }
  1709.   }
  1710.   logError(err, vm, info);
  1711. }
  1712.  
  1713. function logError (err, vm, info) {
  1714.   {
  1715.     warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
  1716.   }
  1717.   /* istanbul ignore else */
  1718.   if ((inBrowser || inWeex) && typeof console !== 'undefined') {
  1719.     console.error(err);
  1720.   } else {
  1721.     throw err
  1722.   }
  1723. }
  1724.  
  1725. /*  */
  1726. /* globals MessageChannel */
  1727.  
  1728. var callbacks = [];
  1729. var pending = false;
  1730.  
  1731. function flushCallbacks () {
  1732.   pending = false;
  1733.   var copies = callbacks.slice(0);
  1734.   callbacks.length = 0;
  1735.   for (var i = 0; i < copies.length; i++) {
  1736.     copies[i]();
  1737.   }
  1738. }
  1739.  
  1740. // Here we have async deferring wrappers using both micro and macro tasks.
  1741. // In < 2.4 we used micro tasks everywhere, but there are some scenarios where
  1742. // micro tasks have too high a priority and fires in between supposedly
  1743. // sequential events (e.g. #4521, #6690) or even between bubbling of the same
  1744. // event (#6566). However, using macro tasks everywhere also has subtle problems
  1745. // when state is changed right before repaint (e.g. #6813, out-in transitions).
  1746. // Here we use micro task by default, but expose a way to force macro task when
  1747. // needed (e.g. in event handlers attached by v-on).
  1748. var microTimerFunc;
  1749. var macroTimerFunc;
  1750. var useMacroTask = false;
  1751.  
  1752. // Determine (macro) Task defer implementation.
  1753. // Technically setImmediate should be the ideal choice, but it's only available
  1754. // in IE. The only polyfill that consistently queues the callback after all DOM
  1755. // events triggered in the same loop is by using MessageChannel.
  1756. /* istanbul ignore if */
  1757. if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
  1758.   macroTimerFunc = function () {
  1759.     setImmediate(flushCallbacks);
  1760.   };
  1761. } else if (typeof MessageChannel !== 'undefined' && (
  1762.   isNative(MessageChannel) ||
  1763.   // PhantomJS
  1764.   MessageChannel.toString() === '[object MessageChannelConstructor]'
  1765. )) {
  1766.   var channel = new MessageChannel();
  1767.   var port = channel.port2;
  1768.   channel.port1.onmessage = flushCallbacks;
  1769.   macroTimerFunc = function () {
  1770.     port.postMessage(1);
  1771.   };
  1772. } else {
  1773.   /* istanbul ignore next */
  1774.   macroTimerFunc = function () {
  1775.     setTimeout(flushCallbacks, 0);
  1776.   };
  1777. }
  1778.  
  1779. // Determine MicroTask defer implementation.
  1780. /* istanbul ignore next, $flow-disable-line */
  1781. if (typeof Promise !== 'undefined' && isNative(Promise)) {
  1782.   var p = Promise.resolve();
  1783.   microTimerFunc = function () {
  1784.     p.then(flushCallbacks);
  1785.     // in problematic UIWebViews, Promise.then doesn't completely break, but
  1786.     // it can get stuck in a weird state where callbacks are pushed into the
  1787.     // microtask queue but the queue isn't being flushed, until the browser
  1788.     // needs to do some other work, e.g. handle a timer. Therefore we can
  1789.     // "force" the microtask queue to be flushed by adding an empty timer.
  1790.     if (isIOS) { setTimeout(noop); }
  1791.   };
  1792. } else {
  1793.   // fallback to macro
  1794.   microTimerFunc = macroTimerFunc;
  1795. }
  1796.  
  1797. /**
  1798.  * Wrap a function so that if any code inside triggers state change,
  1799.  * the changes are queued using a Task instead of a MicroTask.
  1800.  */
  1801. function withMacroTask (fn) {
  1802.   return fn._withTask || (fn._withTask = function () {
  1803.     useMacroTask = true;
  1804.     var res = fn.apply(null, arguments);
  1805.     useMacroTask = false;
  1806.     return res
  1807.   })
  1808. }
  1809.  
  1810. function nextTick (cb, ctx) {
  1811.   var _resolve;
  1812.   callbacks.push(function () {
  1813.     if (cb) {
  1814.       try {
  1815.         cb.call(ctx);
  1816.       } catch (e) {
  1817.         handleError(e, ctx, 'nextTick');
  1818.       }
  1819.     } else if (_resolve) {
  1820.       _resolve(ctx);
  1821.     }
  1822.   });
  1823.   if (!pending) {
  1824.     pending = true;
  1825.     if (useMacroTask) {
  1826.       macroTimerFunc();
  1827.     } else {
  1828.       microTimerFunc();
  1829.     }
  1830.   }
  1831.   // $flow-disable-line
  1832.   if (!cb && typeof Promise !== 'undefined') {
  1833.     return new Promise(function (resolve) {
  1834.       _resolve = resolve;
  1835.     })
  1836.   }
  1837. }
  1838.  
  1839. /*  */
  1840.  
  1841. var mark;
  1842. var measure;
  1843.  
  1844. {
  1845.   var perf = inBrowser && window.performance;
  1846.   /* istanbul ignore if */
  1847.   if (
  1848.     perf &&
  1849.     perf.mark &&
  1850.     perf.measure &&
  1851.     perf.clearMarks &&
  1852.     perf.clearMeasures
  1853.   ) {
  1854.     mark = function (tag) { return perf.mark(tag); };
  1855.     measure = function (name, startTag, endTag) {
  1856.       perf.measure(name, startTag, endTag);
  1857.       perf.clearMarks(startTag);
  1858.       perf.clearMarks(endTag);
  1859.       perf.clearMeasures(name);
  1860.     };
  1861.   }
  1862. }
  1863.  
  1864. /* not type checking this file because flow doesn't play well with Proxy */
  1865.  
  1866. var initProxy;
  1867.  
  1868. {
  1869.   var allowedGlobals = makeMap(
  1870.     'Infinity,undefined,NaN,isFinite,isNaN,' +
  1871.     'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
  1872.     'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
  1873.     'require' // for Webpack/Browserify
  1874.   );
  1875.  
  1876.   var warnNonPresent = function (target, key) {
  1877.     warn(
  1878.       "Property or method \"" + key + "\" is not defined on the instance but " +
  1879.       'referenced during render. Make sure that this property is reactive, ' +
  1880.       'either in the data option, or for class-based components, by ' +
  1881.       'initializing the property. ' +
  1882.       'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
  1883.       target
  1884.     );
  1885.   };
  1886.  
  1887.   var hasProxy =
  1888.     typeof Proxy !== 'undefined' &&
  1889.     Proxy.toString().match(/native code/);
  1890.  
  1891.   if (hasProxy) {
  1892.     var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
  1893.     config.keyCodes = new Proxy(config.keyCodes, {
  1894.       set: function set (target, key, value) {
  1895.         if (isBuiltInModifier(key)) {
  1896.           warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
  1897.           return false
  1898.         } else {
  1899.           target[key] = value;
  1900.           return true
  1901.         }
  1902.       }
  1903.     });
  1904.   }
  1905.  
  1906.   var hasHandler = {
  1907.     has: function has (target, key) {
  1908.       var has = key in target;
  1909.       var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
  1910.       if (!has && !isAllowed) {
  1911.         warnNonPresent(target, key);
  1912.       }
  1913.       return has || !isAllowed
  1914.     }
  1915.   };
  1916.  
  1917.   var getHandler = {
  1918.     get: function get (target, key) {
  1919.       if (typeof key === 'string' && !(key in target)) {
  1920.         warnNonPresent(target, key);
  1921.       }
  1922.       return target[key]
  1923.     }
  1924.   };
  1925.  
  1926.   initProxy = function initProxy (vm) {
  1927.     if (hasProxy) {
  1928.       // determine which proxy handler to use
  1929.       var options = vm.$options;
  1930.       var handlers = options.render && options.render._withStripped
  1931.         ? getHandler
  1932.         : hasHandler;
  1933.       vm._renderProxy = new Proxy(vm, handlers);
  1934.     } else {
  1935.       vm._renderProxy = vm;
  1936.     }
  1937.   };
  1938. }
  1939.  
  1940. /*  */
  1941.  
  1942. var seenObjects = new _Set();
  1943.  
  1944. /**
  1945.  * Recursively traverse an object to evoke all converted
  1946.  * getters, so that every nested property inside the object
  1947.  * is collected as a "deep" dependency.
  1948.  */
  1949. function traverse (val) {
  1950.   _traverse(val, seenObjects);
  1951.   seenObjects.clear();
  1952. }
  1953.  
  1954. function _traverse (val, seen) {
  1955.   var i, keys;
  1956.   var isA = Array.isArray(val);
  1957.   if ((!isA && !isObject(val)) || Object.isFrozen(val)) {
  1958.     return
  1959.   }
  1960.   if (val.__ob__) {
  1961.     var depId = val.__ob__.dep.id;
  1962.     if (seen.has(depId)) {
  1963.       return
  1964.     }
  1965.     seen.add(depId);
  1966.   }
  1967.   if (isA) {
  1968.     i = val.length;
  1969.     while (i--) { _traverse(val[i], seen); }
  1970.   } else {
  1971.     keys = Object.keys(val);
  1972.     i = keys.length;
  1973.     while (i--) { _traverse(val[keys[i]], seen); }
  1974.   }
  1975. }
  1976.  
  1977. /*  */
  1978.  
  1979. var normalizeEvent = cached(function (name) {
  1980.   var passive = name.charAt(0) === '&';
  1981.   name = passive ? name.slice(1) : name;
  1982.   var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
  1983.   name = once$$1 ? name.slice(1) : name;
  1984.   var capture = name.charAt(0) === '!';
  1985.   name = capture ? name.slice(1) : name;
  1986.   return {
  1987.     name: name,
  1988.     once: once$$1,
  1989.     capture: capture,
  1990.     passive: passive
  1991.   }
  1992. });
  1993.  
  1994. function createFnInvoker (fns) {
  1995.   function invoker () {
  1996.     var arguments$1 = arguments;
  1997.  
  1998.     var fns = invoker.fns;
  1999.     if (Array.isArray(fns)) {
  2000.       var cloned = fns.slice();
  2001.       for (var i = 0; i < cloned.length; i++) {
  2002.         cloned[i].apply(null, arguments$1);
  2003.       }
  2004.     } else {
  2005.       // return handler return value for single handlers
  2006.       return fns.apply(null, arguments)
  2007.     }
  2008.   }
  2009.   invoker.fns = fns;
  2010.   return invoker
  2011. }
  2012.  
  2013. function updateListeners (
  2014.   on,
  2015.   oldOn,
  2016.   add,
  2017.   remove$$1,
  2018.   vm
  2019. ) {
  2020.   var name, def, cur, old, event;
  2021.   for (name in on) {
  2022.     def = cur = on[name];
  2023.     old = oldOn[name];
  2024.     event = normalizeEvent(name);
  2025.     /* istanbul ignore if */
  2026.     if (isUndef(cur)) {
  2027.       "development" !== 'production' && warn(
  2028.         "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
  2029.         vm
  2030.       );
  2031.     } else if (isUndef(old)) {
  2032.       if (isUndef(cur.fns)) {
  2033.         cur = on[name] = createFnInvoker(cur);
  2034.       }
  2035.       add(event.name, cur, event.once, event.capture, event.passive, event.params);
  2036.     } else if (cur !== old) {
  2037.       old.fns = cur;
  2038.       on[name] = old;
  2039.     }
  2040.   }
  2041.   for (name in oldOn) {
  2042.     if (isUndef(on[name])) {
  2043.       event = normalizeEvent(name);
  2044.       remove$$1(event.name, oldOn[name], event.capture);
  2045.     }
  2046.   }
  2047. }
  2048.  
  2049. /*  */
  2050.  
  2051. function mergeVNodeHook (def, hookKey, hook) {
  2052.   if (def instanceof VNode) {
  2053.     def = def.data.hook || (def.data.hook = {});
  2054.   }
  2055.   var invoker;
  2056.   var oldHook = def[hookKey];
  2057.  
  2058.   function wrappedHook () {
  2059.     hook.apply(this, arguments);
  2060.     // important: remove merged hook to ensure it's called only once
  2061.     // and prevent memory leak
  2062.     remove(invoker.fns, wrappedHook);
  2063.   }
  2064.  
  2065.   if (isUndef(oldHook)) {
  2066.     // no existing hook
  2067.     invoker = createFnInvoker([wrappedHook]);
  2068.   } else {
  2069.     /* istanbul ignore if */
  2070.     if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
  2071.       // already a merged invoker
  2072.       invoker = oldHook;
  2073.       invoker.fns.push(wrappedHook);
  2074.     } else {
  2075.       // existing plain hook
  2076.       invoker = createFnInvoker([oldHook, wrappedHook]);
  2077.     }
  2078.   }
  2079.  
  2080.   invoker.merged = true;
  2081.   def[hookKey] = invoker;
  2082. }
  2083.  
  2084. /*  */
  2085.  
  2086. function extractPropsFromVNodeData (
  2087.   data,
  2088.   Ctor,
  2089.   tag
  2090. ) {
  2091.   // we are only extracting raw values here.
  2092.   // validation and default values are handled in the child
  2093.   // component itself.
  2094.   var propOptions = Ctor.options.props;
  2095.   if (isUndef(propOptions)) {
  2096.     return
  2097.   }
  2098.   var res = {};
  2099.   var attrs = data.attrs;
  2100.   var props = data.props;
  2101.   if (isDef(attrs) || isDef(props)) {
  2102.     for (var key in propOptions) {
  2103.       var altKey = hyphenate(key);
  2104.       {
  2105.         var keyInLowerCase = key.toLowerCase();
  2106.         if (
  2107.           key !== keyInLowerCase &&
  2108.           attrs && hasOwn(attrs, keyInLowerCase)
  2109.         ) {
  2110.           tip(
  2111.             "Prop \"" + keyInLowerCase + "\" is passed to component " +
  2112.             (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
  2113.             " \"" + key + "\". " +
  2114.             "Note that HTML attributes are case-insensitive and camelCased " +
  2115.             "props need to use their kebab-case equivalents when using in-DOM " +
  2116.             "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
  2117.           );
  2118.         }
  2119.       }
  2120.       checkProp(res, props, key, altKey, true) ||
  2121.       checkProp(res, attrs, key, altKey, false);
  2122.     }
  2123.   }
  2124.   return res
  2125. }
  2126.  
  2127. function checkProp (
  2128.   res,
  2129.   hash,
  2130.   key,
  2131.   altKey,
  2132.   preserve
  2133. ) {
  2134.   if (isDef(hash)) {
  2135.     if (hasOwn(hash, key)) {
  2136.       res[key] = hash[key];
  2137.       if (!preserve) {
  2138.         delete hash[key];
  2139.       }
  2140.       return true
  2141.     } else if (hasOwn(hash, altKey)) {
  2142.       res[key] = hash[altKey];
  2143.       if (!preserve) {
  2144.         delete hash[altKey];
  2145.       }
  2146.       return true
  2147.     }
  2148.   }
  2149.   return false
  2150. }
  2151.  
  2152. /*  */
  2153.  
  2154. // The template compiler attempts to minimize the need for normalization by
  2155. // statically analyzing the template at compile time.
  2156. //
  2157. // For plain HTML markup, normalization can be completely skipped because the
  2158. // generated render function is guaranteed to return Array<VNode>. There are
  2159. // two cases where extra normalization is needed:
  2160.  
  2161. // 1. When the children contains components - because a functional component
  2162. // may return an Array instead of a single root. In this case, just a simple
  2163. // normalization is needed - if any child is an Array, we flatten the whole
  2164. // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
  2165. // because functional components already normalize their own children.
  2166. function simpleNormalizeChildren (children) {
  2167.   for (var i = 0; i < children.length; i++) {
  2168.     if (Array.isArray(children[i])) {
  2169.       return Array.prototype.concat.apply([], children)
  2170.     }
  2171.   }
  2172.   return children
  2173. }
  2174.  
  2175. // 2. When the children contains constructs that always generated nested Arrays,
  2176. // e.g. <template>, <slot>, v-for, or when the children is provided by user
  2177. // with hand-written render functions / JSX. In such cases a full normalization
  2178. // is needed to cater to all possible types of children values.
  2179. function normalizeChildren (children) {
  2180.   return isPrimitive(children)
  2181.     ? [createTextVNode(children)]
  2182.     : Array.isArray(children)
  2183.       ? normalizeArrayChildren(children)
  2184.       : undefined
  2185. }
  2186.  
  2187. function isTextNode (node) {
  2188.   return isDef(node) && isDef(node.text) && isFalse(node.isComment)
  2189. }
  2190.  
  2191. function normalizeArrayChildren (children, nestedIndex) {
  2192.   var res = [];
  2193.   var i, c, lastIndex, last;
  2194.   for (i = 0; i < children.length; i++) {
  2195.     c = children[i];
  2196.     if (isUndef(c) || typeof c === 'boolean') { continue }
  2197.     lastIndex = res.length - 1;
  2198.     last = res[lastIndex];
  2199.     //  nested
  2200.     if (Array.isArray(c)) {
  2201.       if (c.length > 0) {
  2202.         c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
  2203.         // merge adjacent text nodes
  2204.         if (isTextNode(c[0]) && isTextNode(last)) {
  2205.           res[lastIndex] = createTextVNode(last.text + (c[0]).text);
  2206.           c.shift();
  2207.         }
  2208.         res.push.apply(res, c);
  2209.       }
  2210.     } else if (isPrimitive(c)) {
  2211.       if (isTextNode(last)) {
  2212.         // merge adjacent text nodes
  2213.         // this is necessary for SSR hydration because text nodes are
  2214.         // essentially merged when rendered to HTML strings
  2215.         res[lastIndex] = createTextVNode(last.text + c);
  2216.       } else if (c !== '') {
  2217.         // convert primitive to vnode
  2218.         res.push(createTextVNode(c));
  2219.       }
  2220.     } else {
  2221.       if (isTextNode(c) && isTextNode(last)) {
  2222.         // merge adjacent text nodes
  2223.         res[lastIndex] = createTextVNode(last.text + c.text);
  2224.       } else {
  2225.         // default key for nested array children (likely generated by v-for)
  2226.         if (isTrue(children._isVList) &&
  2227.           isDef(c.tag) &&
  2228.           isUndef(c.key) &&
  2229.           isDef(nestedIndex)) {
  2230.           c.key = "__vlist" + nestedIndex + "_" + i + "__";
  2231.         }
  2232.         res.push(c);
  2233.       }
  2234.     }
  2235.   }
  2236.   return res
  2237. }
  2238.  
  2239. /*  */
  2240.  
  2241. function ensureCtor (comp, base) {
  2242.   if (
  2243.     comp.__esModule ||
  2244.     (hasSymbol && comp[Symbol.toStringTag] === 'Module')
  2245.   ) {
  2246.     comp = comp.default;
  2247.   }
  2248.   return isObject(comp)
  2249.     ? base.extend(comp)
  2250.     : comp
  2251. }
  2252.  
  2253. function createAsyncPlaceholder (
  2254.   factory,
  2255.   data,
  2256.   context,
  2257.   children,
  2258.   tag
  2259. ) {
  2260.   var node = createEmptyVNode();
  2261.   node.asyncFactory = factory;
  2262.   node.asyncMeta = { data: data, context: context, children: children, tag: tag };
  2263.   return node
  2264. }
  2265.  
  2266. function resolveAsyncComponent (
  2267.   factory,
  2268.   baseCtor,
  2269.   context
  2270. ) {
  2271.   if (isTrue(factory.error) && isDef(factory.errorComp)) {
  2272.     return factory.errorComp
  2273.   }
  2274.  
  2275.   if (isDef(factory.resolved)) {
  2276.     return factory.resolved
  2277.   }
  2278.  
  2279.   if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
  2280.     return factory.loadingComp
  2281.   }
  2282.  
  2283.   if (isDef(factory.contexts)) {
  2284.     // already pending
  2285.     factory.contexts.push(context);
  2286.   } else {
  2287.     var contexts = factory.contexts = [context];
  2288.     var sync = true;
  2289.  
  2290.     var forceRender = function () {
  2291.       for (var i = 0, l = contexts.length; i < l; i++) {
  2292.         contexts[i].$forceUpdate();
  2293.       }
  2294.     };
  2295.  
  2296.     var resolve = once(function (res) {
  2297.       // cache resolved
  2298.       factory.resolved = ensureCtor(res, baseCtor);
  2299.       // invoke callbacks only if this is not a synchronous resolve
  2300.       // (async resolves are shimmed as synchronous during SSR)
  2301.       if (!sync) {
  2302.         forceRender();
  2303.       }
  2304.     });
  2305.  
  2306.     var reject = once(function (reason) {
  2307.       "development" !== 'production' && warn(
  2308.         "Failed to resolve async component: " + (String(factory)) +
  2309.         (reason ? ("\nReason: " + reason) : '')
  2310.       );
  2311.       if (isDef(factory.errorComp)) {
  2312.         factory.error = true;
  2313.         forceRender();
  2314.       }
  2315.     });
  2316.  
  2317.     var res = factory(resolve, reject);
  2318.  
  2319.     if (isObject(res)) {
  2320.       if (typeof res.then === 'function') {
  2321.         // () => Promise
  2322.         if (isUndef(factory.resolved)) {
  2323.           res.then(resolve, reject);
  2324.         }
  2325.       } else if (isDef(res.component) && typeof res.component.then === 'function') {
  2326.         res.component.then(resolve, reject);
  2327.  
  2328.         if (isDef(res.error)) {
  2329.           factory.errorComp = ensureCtor(res.error, baseCtor);
  2330.         }
  2331.  
  2332.         if (isDef(res.loading)) {
  2333.           factory.loadingComp = ensureCtor(res.loading, baseCtor);
  2334.           if (res.delay === 0) {
  2335.             factory.loading = true;
  2336.           } else {
  2337.             setTimeout(function () {
  2338.               if (isUndef(factory.resolved) && isUndef(factory.error)) {
  2339.                 factory.loading = true;
  2340.                 forceRender();
  2341.               }
  2342.             }, res.delay || 200);
  2343.           }
  2344.         }
  2345.  
  2346.         if (isDef(res.timeout)) {
  2347.           setTimeout(function () {
  2348.             if (isUndef(factory.resolved)) {
  2349.               reject(
  2350.                 "timeout (" + (res.timeout) + "ms)"
  2351.               );
  2352.             }
  2353.           }, res.timeout);
  2354.         }
  2355.       }
  2356.     }
  2357.  
  2358.     sync = false;
  2359.     // return in case resolved synchronously
  2360.     return factory.loading
  2361.       ? factory.loadingComp
  2362.       : factory.resolved
  2363.   }
  2364. }
  2365.  
  2366. /*  */
  2367.  
  2368. function isAsyncPlaceholder (node) {
  2369.   return node.isComment && node.asyncFactory
  2370. }
  2371.  
  2372. /*  */
  2373.  
  2374. function getFirstComponentChild (children) {
  2375.   if (Array.isArray(children)) {
  2376.     for (var i = 0; i < children.length; i++) {
  2377.       var c = children[i];
  2378.       if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
  2379.         return c
  2380.       }
  2381.     }
  2382.   }
  2383. }
  2384.  
  2385. /*  */
  2386.  
  2387. /*  */
  2388.  
  2389. function initEvents (vm) {
  2390.   vm._events = Object.create(null);
  2391.   vm._hasHookEvent = false;
  2392.   // init parent attached events
  2393.   var listeners = vm.$options._parentListeners;
  2394.   if (listeners) {
  2395.     updateComponentListeners(vm, listeners);
  2396.   }
  2397. }
  2398.  
  2399. var target;
  2400.  
  2401. function add (event, fn, once) {
  2402.   if (once) {
  2403.     target.$once(event, fn);
  2404.   } else {
  2405.     target.$on(event, fn);
  2406.   }
  2407. }
  2408.  
  2409. function remove$1 (event, fn) {
  2410.   target.$off(event, fn);
  2411. }
  2412.  
  2413. function updateComponentListeners (
  2414.   vm,
  2415.   listeners,
  2416.   oldListeners
  2417. ) {
  2418.   target = vm;
  2419.   updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
  2420.   target = undefined;
  2421. }
  2422.  
  2423. function eventsMixin (Vue) {
  2424.   var hookRE = /^hook:/;
  2425.   Vue.prototype.$on = function (event, fn) {
  2426.     var this$1 = this;
  2427.  
  2428.     var vm = this;
  2429.     if (Array.isArray(event)) {
  2430.       for (var i = 0, l = event.length; i < l; i++) {
  2431.         this$1.$on(event[i], fn);
  2432.       }
  2433.     } else {
  2434.       (vm._events[event] || (vm._events[event] = [])).push(fn);
  2435.       // optimize hook:event cost by using a boolean flag marked at registration
  2436.       // instead of a hash lookup
  2437.       if (hookRE.test(event)) {
  2438.         vm._hasHookEvent = true;
  2439.       }
  2440.     }
  2441.     return vm
  2442.   };
  2443.  
  2444.   Vue.prototype.$once = function (event, fn) {
  2445.     var vm = this;
  2446.     function on () {
  2447.       vm.$off(event, on);
  2448.       fn.apply(vm, arguments);
  2449.     }
  2450.     on.fn = fn;
  2451.     vm.$on(event, on);
  2452.     return vm
  2453.   };
  2454.  
  2455.   Vue.prototype.$off = function (event, fn) {
  2456.     var this$1 = this;
  2457.  
  2458.     var vm = this;
  2459.     // all
  2460.     if (!arguments.length) {
  2461.       vm._events = Object.create(null);
  2462.       return vm
  2463.     }
  2464.     // array of events
  2465.     if (Array.isArray(event)) {
  2466.       for (var i = 0, l = event.length; i < l; i++) {
  2467.         this$1.$off(event[i], fn);
  2468.       }
  2469.       return vm
  2470.     }
  2471.     // specific event
  2472.     var cbs = vm._events[event];
  2473.     if (!cbs) {
  2474.       return vm
  2475.     }
  2476.     if (!fn) {
  2477.       vm._events[event] = null;
  2478.       return vm
  2479.     }
  2480.     if (fn) {
  2481.       // specific handler
  2482.       var cb;
  2483.       var i$1 = cbs.length;
  2484.       while (i$1--) {
  2485.         cb = cbs[i$1];
  2486.         if (cb === fn || cb.fn === fn) {
  2487.           cbs.splice(i$1, 1);
  2488.           break
  2489.         }
  2490.       }
  2491.     }
  2492.     return vm
  2493.   };
  2494.  
  2495.   Vue.prototype.$emit = function (event) {
  2496.     var vm = this;
  2497.     {
  2498.       var lowerCaseEvent = event.toLowerCase();
  2499.       if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
  2500.         tip(
  2501.           "Event \"" + lowerCaseEvent + "\" is emitted in component " +
  2502.           (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
  2503.           "Note that HTML attributes are case-insensitive and you cannot use " +
  2504.           "v-on to listen to camelCase events when using in-DOM templates. " +
  2505.           "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
  2506.         );
  2507.       }
  2508.     }
  2509.     var cbs = vm._events[event];
  2510.     if (cbs) {
  2511.       cbs = cbs.length > 1 ? toArray(cbs) : cbs;
  2512.       var args = toArray(arguments, 1);
  2513.       for (var i = 0, l = cbs.length; i < l; i++) {
  2514.         try {
  2515.           cbs[i].apply(vm, args);
  2516.         } catch (e) {
  2517.           handleError(e, vm, ("event handler for \"" + event + "\""));
  2518.         }
  2519.       }
  2520.     }
  2521.     return vm
  2522.   };
  2523. }
  2524.  
  2525. /*  */
  2526.  
  2527.  
  2528.  
  2529. /**
  2530.  * Runtime helper for resolving raw children VNodes into a slot object.
  2531.  */
  2532. function resolveSlots (
  2533.   children,
  2534.   context
  2535. ) {
  2536.   var slots = {};
  2537.   if (!children) {
  2538.     return slots
  2539.   }
  2540.   for (var i = 0, l = children.length; i < l; i++) {
  2541.     var child = children[i];
  2542.     var data = child.data;
  2543.     // remove slot attribute if the node is resolved as a Vue slot node
  2544.     if (data && data.attrs && data.attrs.slot) {
  2545.       delete data.attrs.slot;
  2546.     }
  2547.     // named slots should only be respected if the vnode was rendered in the
  2548.     // same context.
  2549.     if ((child.context === context || child.fnContext === context) &&
  2550.       data && data.slot != null
  2551.     ) {
  2552.       var name = data.slot;
  2553.       var slot = (slots[name] || (slots[name] = []));
  2554.       if (child.tag === 'template') {
  2555.         slot.push.apply(slot, child.children || []);
  2556.       } else {
  2557.         slot.push(child);
  2558.       }
  2559.     } else {
  2560.       (slots.default || (slots.default = [])).push(child);
  2561.     }
  2562.   }
  2563.   // ignore slots that contains only whitespace
  2564.   for (var name$1 in slots) {
  2565.     if (slots[name$1].every(isWhitespace)) {
  2566.       delete slots[name$1];
  2567.     }
  2568.   }
  2569.   return slots
  2570. }
  2571.  
  2572. function isWhitespace (node) {
  2573.   return (node.isComment && !node.asyncFactory) || node.text === ' '
  2574. }
  2575.  
  2576. function resolveScopedSlots (
  2577.   fns, // see flow/vnode
  2578.   res
  2579. ) {
  2580.   res = res || {};
  2581.   for (var i = 0; i < fns.length; i++) {
  2582.     if (Array.isArray(fns[i])) {
  2583.       resolveScopedSlots(fns[i], res);
  2584.     } else {
  2585.       res[fns[i].key] = fns[i].fn;
  2586.     }
  2587.   }
  2588.   return res
  2589. }
  2590.  
  2591. /*  */
  2592.  
  2593. var activeInstance = null;
  2594. var isUpdatingChildComponent = false;
  2595.  
  2596. function initLifecycle (vm) {
  2597.   var options = vm.$options;
  2598.  
  2599.   // locate first non-abstract parent
  2600.   var parent = options.parent;
  2601.   if (parent && !options.abstract) {
  2602.     while (parent.$options.abstract && parent.$parent) {
  2603.       parent = parent.$parent;
  2604.     }
  2605.     parent.$children.push(vm);
  2606.   }
  2607.  
  2608.   vm.$parent = parent;
  2609.   vm.$root = parent ? parent.$root : vm;
  2610.  
  2611.   vm.$children = [];
  2612.   vm.$refs = {};
  2613.  
  2614.   vm._watcher = null;
  2615.   vm._inactive = null;
  2616.   vm._directInactive = false;
  2617.   vm._isMounted = false;
  2618.   vm._isDestroyed = false;
  2619.   vm._isBeingDestroyed = false;
  2620. }
  2621.  
  2622. function lifecycleMixin (Vue) {
  2623.   Vue.prototype._update = function (vnode, hydrating) {
  2624.     var vm = this;
  2625.     if (vm._isMounted) {
  2626.       callHook(vm, 'beforeUpdate');
  2627.     }
  2628.     var prevEl = vm.$el;
  2629.     var prevVnode = vm._vnode;
  2630.     var prevActiveInstance = activeInstance;
  2631.     activeInstance = vm;
  2632.     vm._vnode = vnode;
  2633.     // Vue.prototype.__patch__ is injected in entry points
  2634.     // based on the rendering backend used.
  2635.     if (!prevVnode) {
  2636.       // initial render
  2637.       vm.$el = vm.__patch__(
  2638.         vm.$el, vnode, hydrating, false /* removeOnly */,
  2639.         vm.$options._parentElm,
  2640.         vm.$options._refElm
  2641.       );
  2642.       // no need for the ref nodes after initial patch
  2643.       // this prevents keeping a detached DOM tree in memory (#5851)
  2644.       vm.$options._parentElm = vm.$options._refElm = null;
  2645.     } else {
  2646.       // updates
  2647.       vm.$el = vm.__patch__(prevVnode, vnode);
  2648.     }
  2649.     activeInstance = prevActiveInstance;
  2650.     // update __vue__ reference
  2651.     if (prevEl) {
  2652.       prevEl.__vue__ = null;
  2653.     }
  2654.     if (vm.$el) {
  2655.       vm.$el.__vue__ = vm;
  2656.     }
  2657.     // if parent is an HOC, update its $el as well
  2658.     if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
  2659.       vm.$parent.$el = vm.$el;
  2660.     }
  2661.     // updated hook is called by the scheduler to ensure that children are
  2662.     // updated in a parent's updated hook.
  2663.   };
  2664.  
  2665.   Vue.prototype.$forceUpdate = function () {
  2666.     var vm = this;
  2667.     if (vm._watcher) {
  2668.       vm._watcher.update();
  2669.     }
  2670.   };
  2671.  
  2672.   Vue.prototype.$destroy = function () {
  2673.     var vm = this;
  2674.     if (vm._isBeingDestroyed) {
  2675.       return
  2676.     }
  2677.     callHook(vm, 'beforeDestroy');
  2678.     vm._isBeingDestroyed = true;
  2679.     // remove self from parent
  2680.     var parent = vm.$parent;
  2681.     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
  2682.       remove(parent.$children, vm);
  2683.     }
  2684.     // teardown watchers
  2685.     if (vm._watcher) {
  2686.       vm._watcher.teardown();
  2687.     }
  2688.     var i = vm._watchers.length;
  2689.     while (i--) {
  2690.       vm._watchers[i].teardown();
  2691.     }
  2692.     // remove reference from data ob
  2693.     // frozen object may not have observer.
  2694.     if (vm._data.__ob__) {
  2695.       vm._data.__ob__.vmCount--;
  2696.     }
  2697.     // call the last hook...
  2698.     vm._isDestroyed = true;
  2699.     // invoke destroy hooks on current rendered tree
  2700.     vm.__patch__(vm._vnode, null);
  2701.     // fire destroyed hook
  2702.     callHook(vm, 'destroyed');
  2703.     // turn off all instance listeners.
  2704.     vm.$off();
  2705.     // remove __vue__ reference
  2706.     if (vm.$el) {
  2707.       vm.$el.__vue__ = null;
  2708.     }
  2709.     // release circular reference (#6759)
  2710.     if (vm.$vnode) {
  2711.       vm.$vnode.parent = null;
  2712.     }
  2713.   };
  2714. }
  2715.  
  2716. function mountComponent (
  2717.   vm,
  2718.   el,
  2719.   hydrating
  2720. ) {
  2721.   vm.$el = el;
  2722.   if (!vm.$options.render) {
  2723.     vm.$options.render = createEmptyVNode;
  2724.     {
  2725.       /* istanbul ignore if */
  2726.       if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
  2727.         vm.$options.el || el) {
  2728.         warn(
  2729.           'You are using the runtime-only build of Vue where the template ' +
  2730.           'compiler is not available. Either pre-compile the templates into ' +
  2731.           'render functions, or use the compiler-included build.',
  2732.           vm
  2733.         );
  2734.       } else {
  2735.         warn(
  2736.           'Failed to mount component: template or render function not defined.',
  2737.           vm
  2738.         );
  2739.       }
  2740.     }
  2741.   }
  2742.   callHook(vm, 'beforeMount');
  2743.  
  2744.   var updateComponent;
  2745.   /* istanbul ignore if */
  2746.   if ("development" !== 'production' && config.performance && mark) {
  2747.     updateComponent = function () {
  2748.       var name = vm._name;
  2749.       var id = vm._uid;
  2750.       var startTag = "vue-perf-start:" + id;
  2751.       var endTag = "vue-perf-end:" + id;
  2752.  
  2753.       mark(startTag);
  2754.       var vnode = vm._render();
  2755.       mark(endTag);
  2756.       measure(("vue " + name + " render"), startTag, endTag);
  2757.  
  2758.       mark(startTag);
  2759.       vm._update(vnode, hydrating);
  2760.       mark(endTag);
  2761.       measure(("vue " + name + " patch"), startTag, endTag);
  2762.     };
  2763.   } else {
  2764.     updateComponent = function () {
  2765.       vm._update(vm._render(), hydrating);
  2766.     };
  2767.   }
  2768.  
  2769.   // we set this to vm._watcher inside the watcher's constructor
  2770.   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
  2771.   // component's mounted hook), which relies on vm._watcher being already defined
  2772.   new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */);
  2773.   hydrating = false;
  2774.  
  2775.   // manually mounted instance, call mounted on self
  2776.   // mounted is called for render-created child components in its inserted hook
  2777.   if (vm.$vnode == null) {
  2778.     vm._isMounted = true;
  2779.     callHook(vm, 'mounted');
  2780.   }
  2781.   return vm
  2782. }
  2783.  
  2784. function updateChildComponent (
  2785.   vm,
  2786.   propsData,
  2787.   listeners,
  2788.   parentVnode,
  2789.   renderChildren
  2790. ) {
  2791.   {
  2792.     isUpdatingChildComponent = true;
  2793.   }
  2794.  
  2795.   // determine whether component has slot children
  2796.   // we need to do this before overwriting $options._renderChildren
  2797.   var hasChildren = !!(
  2798.     renderChildren ||               // has new static slots
  2799.     vm.$options._renderChildren ||  // has old static slots
  2800.     parentVnode.data.scopedSlots || // has new scoped slots
  2801.     vm.$scopedSlots !== emptyObject // has old scoped slots
  2802.   );
  2803.  
  2804.   vm.$options._parentVnode = parentVnode;
  2805.   vm.$vnode = parentVnode; // update vm's placeholder node without re-render
  2806.  
  2807.   if (vm._vnode) { // update child tree's parent
  2808.     vm._vnode.parent = parentVnode;
  2809.   }
  2810.   vm.$options._renderChildren = renderChildren;
  2811.  
  2812.   // update $attrs and $listeners hash
  2813.   // these are also reactive so they may trigger child update if the child
  2814.   // used them during render
  2815.   vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject;
  2816.   vm.$listeners = listeners || emptyObject;
  2817.  
  2818.   // update props
  2819.   if (propsData && vm.$options.props) {
  2820.     observerState.shouldConvert = false;
  2821.     var props = vm._props;
  2822.     var propKeys = vm.$options._propKeys || [];
  2823.     for (var i = 0; i < propKeys.length; i++) {
  2824.       var key = propKeys[i];
  2825.       props[key] = validateProp(key, vm.$options.props, propsData, vm);
  2826.     }
  2827.     observerState.shouldConvert = true;
  2828.     // keep a copy of raw propsData
  2829.     vm.$options.propsData = propsData;
  2830.   }
  2831.  
  2832.   // update listeners
  2833.   if (listeners) {
  2834.     var oldListeners = vm.$options._parentListeners;
  2835.     vm.$options._parentListeners = listeners;
  2836.     updateComponentListeners(vm, listeners, oldListeners);
  2837.   }
  2838.   // resolve slots + force update if has children
  2839.   if (hasChildren) {
  2840.     vm.$slots = resolveSlots(renderChildren, parentVnode.context);
  2841.     vm.$forceUpdate();
  2842.   }
  2843.  
  2844.   {
  2845.     isUpdatingChildComponent = false;
  2846.   }
  2847. }
  2848.  
  2849. function isInInactiveTree (vm) {
  2850.   while (vm && (vm = vm.$parent)) {
  2851.     if (vm._inactive) { return true }
  2852.   }
  2853.   return false
  2854. }
  2855.  
  2856. function activateChildComponent (vm, direct) {
  2857.   if (direct) {
  2858.     vm._directInactive = false;
  2859.     if (isInInactiveTree(vm)) {
  2860.       return
  2861.     }
  2862.   } else if (vm._directInactive) {
  2863.     return
  2864.   }
  2865.   if (vm._inactive || vm._inactive === null) {
  2866.     vm._inactive = false;
  2867.     for (var i = 0; i < vm.$children.length; i++) {
  2868.       activateChildComponent(vm.$children[i]);
  2869.     }
  2870.     callHook(vm, 'activated');
  2871.   }
  2872. }
  2873.  
  2874. function deactivateChildComponent (vm, direct) {
  2875.   if (direct) {
  2876.     vm._directInactive = true;
  2877.     if (isInInactiveTree(vm)) {
  2878.       return
  2879.     }
  2880.   }
  2881.   if (!vm._inactive) {
  2882.     vm._inactive = true;
  2883.     for (var i = 0; i < vm.$children.length; i++) {
  2884.       deactivateChildComponent(vm.$children[i]);
  2885.     }
  2886.     callHook(vm, 'deactivated');
  2887.   }
  2888. }
  2889.  
  2890. function callHook (vm, hook) {
  2891.   var handlers = vm.$options[hook];
  2892.   if (handlers) {
  2893.     for (var i = 0, j = handlers.length; i < j; i++) {
  2894.       try {
  2895.         handlers[i].call(vm);
  2896.       } catch (e) {
  2897.         handleError(e, vm, (hook + " hook"));
  2898.       }
  2899.     }
  2900.   }
  2901.   if (vm._hasHookEvent) {
  2902.     vm.$emit('hook:' + hook);
  2903.   }
  2904. }
  2905.  
  2906. /*  */
  2907.  
  2908.  
  2909. var MAX_UPDATE_COUNT = 100;
  2910.  
  2911. var queue = [];
  2912. var activatedChildren = [];
  2913. var has = {};
  2914. var circular = {};
  2915. var waiting = false;
  2916. var flushing = false;
  2917. var index = 0;
  2918.  
  2919. /**
  2920.  * Reset the scheduler's state.
  2921.  */
  2922. function resetSchedulerState () {
  2923.   index = queue.length = activatedChildren.length = 0;
  2924.   has = {};
  2925.   {
  2926.     circular = {};
  2927.   }
  2928.   waiting = flushing = false;
  2929. }
  2930.  
  2931. /**
  2932.  * Flush both queues and run the watchers.
  2933.  */
  2934. function flushSchedulerQueue () {
  2935.   flushing = true;
  2936.   var watcher, id;
  2937.  
  2938.   // Sort queue before flush.
  2939.   // This ensures that:
  2940.   // 1. Components are updated from parent to child. (because parent is always
  2941.   //    created before the child)
  2942.   // 2. A component's user watchers are run before its render watcher (because
  2943.   //    user watchers are created before the render watcher)
  2944.   // 3. If a component is destroyed during a parent component's watcher run,
  2945.   //    its watchers can be skipped.
  2946.   queue.sort(function (a, b) { return a.id - b.id; });
  2947.  
  2948.   // do not cache length because more watchers might be pushed
  2949.   // as we run existing watchers
  2950.   for (index = 0; index < queue.length; index++) {
  2951.     watcher = queue[index];
  2952.     id = watcher.id;
  2953.     has[id] = null;
  2954.     watcher.run();
  2955.     // in dev build, check and stop circular updates.
  2956.     if ("development" !== 'production' && has[id] != null) {
  2957.       circular[id] = (circular[id] || 0) + 1;
  2958.       if (circular[id] > MAX_UPDATE_COUNT) {
  2959.         warn(
  2960.           'You may have an infinite update loop ' + (
  2961.             watcher.user
  2962.               ? ("in watcher with expression \"" + (watcher.expression) + "\"")
  2963.               : "in a component render function."
  2964.           ),
  2965.           watcher.vm
  2966.         );
  2967.         break
  2968.       }
  2969.     }
  2970.   }
  2971.  
  2972.   // keep copies of post queues before resetting state
  2973.   var activatedQueue = activatedChildren.slice();
  2974.   var updatedQueue = queue.slice();
  2975.  
  2976.   resetSchedulerState();
  2977.  
  2978.   // call component updated and activated hooks
  2979.   callActivatedHooks(activatedQueue);
  2980.   callUpdatedHooks(updatedQueue);
  2981.  
  2982.   // devtool hook
  2983.   /* istanbul ignore if */
  2984.   if (devtools && config.devtools) {
  2985.     devtools.emit('flush');
  2986.   }
  2987. }
  2988.  
  2989. function callUpdatedHooks (queue) {
  2990.   var i = queue.length;
  2991.   while (i--) {
  2992.     var watcher = queue[i];
  2993.     var vm = watcher.vm;
  2994.     if (vm._watcher === watcher && vm._isMounted) {
  2995.       callHook(vm, 'updated');
  2996.     }
  2997.   }
  2998. }
  2999.  
  3000. /**
  3001.  * Queue a kept-alive component that was activated during patch.
  3002.  * The queue will be processed after the entire tree has been patched.
  3003.  */
  3004. function queueActivatedComponent (vm) {
  3005.   // setting _inactive to false here so that a render function can
  3006.   // rely on checking whether it's in an inactive tree (e.g. router-view)
  3007.   vm._inactive = false;
  3008.   activatedChildren.push(vm);
  3009. }
  3010.  
  3011. function callActivatedHooks (queue) {
  3012.   for (var i = 0; i < queue.length; i++) {
  3013.     queue[i]._inactive = true;
  3014.     activateChildComponent(queue[i], true /* true */);
  3015.   }
  3016. }
  3017.  
  3018. /**
  3019.  * Push a watcher into the watcher queue.
  3020.  * Jobs with duplicate IDs will be skipped unless it's
  3021.  * pushed when the queue is being flushed.
  3022.  */
  3023. function queueWatcher (watcher) {
  3024.   var id = watcher.id;
  3025.   if (has[id] == null) {
  3026.     has[id] = true;
  3027.     if (!flushing) {
  3028.       queue.push(watcher);
  3029.     } else {
  3030.       // if already flushing, splice the watcher based on its id
  3031.       // if already past its id, it will be run next immediately.
  3032.       var i = queue.length - 1;
  3033.       while (i > index && queue[i].id > watcher.id) {
  3034.         i--;
  3035.       }
  3036.       queue.splice(i + 1, 0, watcher);
  3037.     }
  3038.     // queue the flush
  3039.     if (!waiting) {
  3040.       waiting = true;
  3041.       nextTick(flushSchedulerQueue);
  3042.     }
  3043.   }
  3044. }
  3045.  
  3046. /*  */
  3047.  
  3048. var uid$2 = 0;
  3049.  
  3050. /**
  3051.  * A watcher parses an expression, collects dependencies,
  3052.  * and fires callback when the expression value changes.
  3053.  * This is used for both the $watch() api and directives.
  3054.  */
  3055. var Watcher = function Watcher (
  3056.   vm,
  3057.   expOrFn,
  3058.   cb,
  3059.   options,
  3060.   isRenderWatcher
  3061. ) {
  3062.   this.vm = vm;
  3063.   if (isRenderWatcher) {
  3064.     vm._watcher = this;
  3065.   }
  3066.   vm._watchers.push(this);
  3067.   // options
  3068.   if (options) {
  3069.     this.deep = !!options.deep;
  3070.     this.user = !!options.user;
  3071.     this.lazy = !!options.lazy;
  3072.     this.sync = !!options.sync;
  3073.   } else {
  3074.     this.deep = this.user = this.lazy = this.sync = false;
  3075.   }
  3076.   this.cb = cb;
  3077.   this.id = ++uid$2; // uid for batching
  3078.   this.active = true;
  3079.   this.dirty = this.lazy; // for lazy watchers
  3080.   this.deps = [];
  3081.   this.newDeps = [];
  3082.   this.depIds = new _Set();
  3083.   this.newDepIds = new _Set();
  3084.   this.expression = expOrFn.toString();
  3085.   // parse expression for getter
  3086.   if (typeof expOrFn === 'function') {
  3087.     this.getter = expOrFn;
  3088.   } else {
  3089.     this.getter = parsePath(expOrFn);
  3090.     if (!this.getter) {
  3091.       this.getter = function () {};
  3092.       "development" !== 'production' && warn(
  3093.         "Failed watching path: \"" + expOrFn + "\" " +
  3094.         'Watcher only accepts simple dot-delimited paths. ' +
  3095.         'For full control, use a function instead.',
  3096.         vm
  3097.       );
  3098.     }
  3099.   }
  3100.   this.value = this.lazy
  3101.     ? undefined
  3102.     : this.get();
  3103. };
  3104.  
  3105. /**
  3106.  * Evaluate the getter, and re-collect dependencies.
  3107.  */
  3108. Watcher.prototype.get = function get () {
  3109.   pushTarget(this);
  3110.   var value;
  3111.   var vm = this.vm;
  3112.   try {
  3113.     value = this.getter.call(vm, vm);
  3114.   } catch (e) {
  3115.     if (this.user) {
  3116.       handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
  3117.     } else {
  3118.       throw e
  3119.     }
  3120.   } finally {
  3121.     // "touch" every property so they are all tracked as
  3122.     // dependencies for deep watching
  3123.     if (this.deep) {
  3124.       traverse(value);
  3125.     }
  3126.     popTarget();
  3127.     this.cleanupDeps();
  3128.   }
  3129.   return value
  3130. };
  3131.  
  3132. /**
  3133.  * Add a dependency to this directive.
  3134.  */
  3135. Watcher.prototype.addDep = function addDep (dep) {
  3136.   var id = dep.id;
  3137.   if (!this.newDepIds.has(id)) {
  3138.     this.newDepIds.add(id);
  3139.     this.newDeps.push(dep);
  3140.     if (!this.depIds.has(id)) {
  3141.       dep.addSub(this);
  3142.     }
  3143.   }
  3144. };
  3145.  
  3146. /**
  3147.  * Clean up for dependency collection.
  3148.  */
  3149. Watcher.prototype.cleanupDeps = function cleanupDeps () {
  3150.     var this$1 = this;
  3151.  
  3152.   var i = this.deps.length;
  3153.   while (i--) {
  3154.     var dep = this$1.deps[i];
  3155.     if (!this$1.newDepIds.has(dep.id)) {
  3156.       dep.removeSub(this$1);
  3157.     }
  3158.   }
  3159.   var tmp = this.depIds;
  3160.   this.depIds = this.newDepIds;
  3161.   this.newDepIds = tmp;
  3162.   this.newDepIds.clear();
  3163.   tmp = this.deps;
  3164.   this.deps = this.newDeps;
  3165.   this.newDeps = tmp;
  3166.   this.newDeps.length = 0;
  3167. };
  3168.  
  3169. /**
  3170.  * Subscriber interface.
  3171.  * Will be called when a dependency changes.
  3172.  */
  3173. Watcher.prototype.update = function update () {
  3174.   /* istanbul ignore else */
  3175.   if (this.lazy) {
  3176.     this.dirty = true;
  3177.   } else if (this.sync) {
  3178.     this.run();
  3179.   } else {
  3180.     queueWatcher(this);
  3181.   }
  3182. };
  3183.  
  3184. /**
  3185.  * Scheduler job interface.
  3186.  * Will be called by the scheduler.
  3187.  */
  3188. Watcher.prototype.run = function run () {
  3189.   if (this.active) {
  3190.     var value = this.get();
  3191.     if (
  3192.       value !== this.value ||
  3193.       // Deep watchers and watchers on Object/Arrays should fire even
  3194.       // when the value is the same, because the value may
  3195.       // have mutated.
  3196.       isObject(value) ||
  3197.       this.deep
  3198.     ) {
  3199.       // set new value
  3200.       var oldValue = this.value;
  3201.       this.value = value;
  3202.       if (this.user) {
  3203.         try {
  3204.           this.cb.call(this.vm, value, oldValue);
  3205.         } catch (e) {
  3206.           handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
  3207.         }
  3208.       } else {
  3209.         this.cb.call(this.vm, value, oldValue);
  3210.       }
  3211.     }
  3212.   }
  3213. };
  3214.  
  3215. /**
  3216.  * Evaluate the value of the watcher.
  3217.  * This only gets called for lazy watchers.
  3218.  */
  3219. Watcher.prototype.evaluate = function evaluate () {
  3220.   this.value = this.get();
  3221.   this.dirty = false;
  3222. };
  3223.  
  3224. /**
  3225.  * Depend on all deps collected by this watcher.
  3226.  */
  3227. Watcher.prototype.depend = function depend () {
  3228.     var this$1 = this;
  3229.  
  3230.   var i = this.deps.length;
  3231.   while (i--) {
  3232.     this$1.deps[i].depend();
  3233.   }
  3234. };
  3235.  
  3236. /**
  3237.  * Remove self from all dependencies' subscriber list.
  3238.  */
  3239. Watcher.prototype.teardown = function teardown () {
  3240.     var this$1 = this;
  3241.  
  3242.   if (this.active) {
  3243.     // remove self from vm's watcher list
  3244.     // this is a somewhat expensive operation so we skip it
  3245.     // if the vm is being destroyed.
  3246.     if (!this.vm._isBeingDestroyed) {
  3247.       remove(this.vm._watchers, this);
  3248.     }
  3249.     var i = this.deps.length;
  3250.     while (i--) {
  3251.       this$1.deps[i].removeSub(this$1);
  3252.     }
  3253.     this.active = false;
  3254.   }
  3255. };
  3256.  
  3257. /*  */
  3258.  
  3259. var sharedPropertyDefinition = {
  3260.   enumerable: true,
  3261.   configurable: true,
  3262.   get: noop,
  3263.   set: noop
  3264. };
  3265.  
  3266. function proxy (target, sourceKey, key) {
  3267.   sharedPropertyDefinition.get = function proxyGetter () {
  3268.     return this[sourceKey][key]
  3269.   };
  3270.   sharedPropertyDefinition.set = function proxySetter (val) {
  3271.     this[sourceKey][key] = val;
  3272.   };
  3273.   Object.defineProperty(target, key, sharedPropertyDefinition);
  3274. }
  3275.  
  3276. function initState (vm) {
  3277.   vm._watchers = [];
  3278.   var opts = vm.$options;
  3279.   if (opts.props) { initProps(vm, opts.props); }
  3280.   if (opts.methods) { initMethods(vm, opts.methods); }
  3281.   if (opts.data) {
  3282.     initData(vm);
  3283.   } else {
  3284.     observe(vm._data = {}, true /* asRootData */);
  3285.   }
  3286.   if (opts.computed) { initComputed(vm, opts.computed); }
  3287.   if (opts.watch && opts.watch !== nativeWatch) {
  3288.     initWatch(vm, opts.watch);
  3289.   }
  3290. }
  3291.  
  3292. function initProps (vm, propsOptions) {
  3293.   var propsData = vm.$options.propsData || {};
  3294.   var props = vm._props = {};
  3295.   // cache prop keys so that future props updates can iterate using Array
  3296.   // instead of dynamic object key enumeration.
  3297.   var keys = vm.$options._propKeys = [];
  3298.   var isRoot = !vm.$parent;
  3299.   // root instance props should be converted
  3300.   observerState.shouldConvert = isRoot;
  3301.   var loop = function ( key ) {
  3302.     keys.push(key);
  3303.     var value = validateProp(key, propsOptions, propsData, vm);
  3304.     /* istanbul ignore else */
  3305.     {
  3306.       var hyphenatedKey = hyphenate(key);
  3307.       if (isReservedAttribute(hyphenatedKey) ||
  3308.           config.isReservedAttr(hyphenatedKey)) {
  3309.         warn(
  3310.           ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
  3311.           vm
  3312.         );
  3313.       }
  3314.       defineReactive(props, key, value, function () {
  3315.         if (vm.$parent && !isUpdatingChildComponent) {
  3316.           warn(
  3317.             "Avoid mutating a prop directly since the value will be " +
  3318.             "overwritten whenever the parent component re-renders. " +
  3319.             "Instead, use a data or computed property based on the prop's " +
  3320.             "value. Prop being mutated: \"" + key + "\"",
  3321.             vm
  3322.           );
  3323.         }
  3324.       });
  3325.     }
  3326.     // static props are already proxied on the component's prototype
  3327.     // during Vue.extend(). We only need to proxy props defined at
  3328.     // instantiation here.
  3329.     if (!(key in vm)) {
  3330.       proxy(vm, "_props", key);
  3331.     }
  3332.   };
  3333.  
  3334.   for (var key in propsOptions) loop( key );
  3335.   observerState.shouldConvert = true;
  3336. }
  3337.  
  3338. function initData (vm) {
  3339.   var data = vm.$options.data;
  3340.   data = vm._data = typeof data === 'function'
  3341.     ? getData(data, vm)
  3342.     : data || {};
  3343.   if (!isPlainObject(data)) {
  3344.     data = {};
  3345.     "development" !== 'production' && warn(
  3346.       'data functions should return an object:\n' +
  3347.       'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
  3348.       vm
  3349.     );
  3350.   }
  3351.   // proxy data on instance
  3352.   var keys = Object.keys(data);
  3353.   var props = vm.$options.props;
  3354.   var methods = vm.$options.methods;
  3355.   var i = keys.length;
  3356.   while (i--) {
  3357.     var key = keys[i];
  3358.     {
  3359.       if (methods && hasOwn(methods, key)) {
  3360.         warn(
  3361.           ("Method \"" + key + "\" has already been defined as a data property."),
  3362.           vm
  3363.         );
  3364.       }
  3365.     }
  3366.     if (props && hasOwn(props, key)) {
  3367.       "development" !== 'production' && warn(
  3368.         "The data property \"" + key + "\" is already declared as a prop. " +
  3369.         "Use prop default value instead.",
  3370.         vm
  3371.       );
  3372.     } else if (!isReserved(key)) {
  3373.       proxy(vm, "_data", key);
  3374.     }
  3375.   }
  3376.   // observe data
  3377.   observe(data, true /* asRootData */);
  3378. }
  3379.  
  3380. function getData (data, vm) {
  3381.   try {
  3382.     return data.call(vm, vm)
  3383.   } catch (e) {
  3384.     handleError(e, vm, "data()");
  3385.     return {}
  3386.   }
  3387. }
  3388.  
  3389. var computedWatcherOptions = { lazy: true };
  3390.  
  3391. function initComputed (vm, computed) {
  3392.   // $flow-disable-line
  3393.   var watchers = vm._computedWatchers = Object.create(null);
  3394.   // computed properties are just getters during SSR
  3395.   var isSSR = isServerRendering();
  3396.  
  3397.   for (var key in computed) {
  3398.     var userDef = computed[key];
  3399.     var getter = typeof userDef === 'function' ? userDef : userDef.get;
  3400.     if ("development" !== 'production' && getter == null) {
  3401.       warn(
  3402.         ("Getter is missing for computed property \"" + key + "\"."),
  3403.         vm
  3404.       );
  3405.     }
  3406.  
  3407.     if (!isSSR) {
  3408.       // create internal watcher for the computed property.
  3409.       watchers[key] = new Watcher(
  3410.         vm,
  3411.         getter || noop,
  3412.         noop,
  3413.         computedWatcherOptions
  3414.       );
  3415.     }
  3416.  
  3417.     // component-defined computed properties are already defined on the
  3418.     // component prototype. We only need to define computed properties defined
  3419.     // at instantiation here.
  3420.     if (!(key in vm)) {
  3421.       defineComputed(vm, key, userDef);
  3422.     } else {
  3423.       if (key in vm.$data) {
  3424.         warn(("The computed property \"" + key + "\" is already defined in data."), vm);
  3425.       } else if (vm.$options.props && key in vm.$options.props) {
  3426.         warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
  3427.       }
  3428.     }
  3429.   }
  3430. }
  3431.  
  3432. function defineComputed (
  3433.   target,
  3434.   key,
  3435.   userDef
  3436. ) {
  3437.   var shouldCache = !isServerRendering();
  3438.   if (typeof userDef === 'function') {
  3439.     sharedPropertyDefinition.get = shouldCache
  3440.       ? createComputedGetter(key)
  3441.       : userDef;
  3442.     sharedPropertyDefinition.set = noop;
  3443.   } else {
  3444.     sharedPropertyDefinition.get = userDef.get
  3445.       ? shouldCache && userDef.cache !== false
  3446.         ? createComputedGetter(key)
  3447.         : userDef.get
  3448.       : noop;
  3449.     sharedPropertyDefinition.set = userDef.set
  3450.       ? userDef.set
  3451.       : noop;
  3452.   }
  3453.   if ("development" !== 'production' &&
  3454.       sharedPropertyDefinition.set === noop) {
  3455.     sharedPropertyDefinition.set = function () {
  3456.       warn(
  3457.         ("Computed property \"" + key + "\" was assigned to but it has no setter."),
  3458.         this
  3459.       );
  3460.     };
  3461.   }
  3462.   Object.defineProperty(target, key, sharedPropertyDefinition);
  3463. }
  3464.  
  3465. function createComputedGetter (key) {
  3466.   return function computedGetter () {
  3467.     var watcher = this._computedWatchers && this._computedWatchers[key];
  3468.     if (watcher) {
  3469.       if (watcher.dirty) {
  3470.         watcher.evaluate();
  3471.       }
  3472.       if (Dep.target) {
  3473.         watcher.depend();
  3474.       }
  3475.       return watcher.value
  3476.     }
  3477.   }
  3478. }
  3479.  
  3480. function initMethods (vm, methods) {
  3481.   var props = vm.$options.props;
  3482.   for (var key in methods) {
  3483.     {
  3484.       if (methods[key] == null) {
  3485.         warn(
  3486.           "Method \"" + key + "\" has an undefined value in the component definition. " +
  3487.           "Did you reference the function correctly?",
  3488.           vm
  3489.         );
  3490.       }
  3491.       if (props && hasOwn(props, key)) {
  3492.         warn(
  3493.           ("Method \"" + key + "\" has already been defined as a prop."),
  3494.           vm
  3495.         );
  3496.       }
  3497.       if ((key in vm) && isReserved(key)) {
  3498.         warn(
  3499.           "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
  3500.           "Avoid defining component methods that start with _ or $."
  3501.         );
  3502.       }
  3503.     }
  3504.     vm[key] = methods[key] == null ? noop : bind(methods[key], vm);
  3505.   }
  3506. }
  3507.  
  3508. function initWatch (vm, watch) {
  3509.   for (var key in watch) {
  3510.     var handler = watch[key];
  3511.     if (Array.isArray(handler)) {
  3512.       for (var i = 0; i < handler.length; i++) {
  3513.         createWatcher(vm, key, handler[i]);
  3514.       }
  3515.     } else {
  3516.       createWatcher(vm, key, handler);
  3517.     }
  3518.   }
  3519. }
  3520.  
  3521. function createWatcher (
  3522.   vm,
  3523.   keyOrFn,
  3524.   handler,
  3525.   options
  3526. ) {
  3527.   if (isPlainObject(handler)) {
  3528.     options = handler;
  3529.     handler = handler.handler;
  3530.   }
  3531.   if (typeof handler === 'string') {
  3532.     handler = vm[handler];
  3533.   }
  3534.   return vm.$watch(keyOrFn, handler, options)
  3535. }
  3536.  
  3537. function stateMixin (Vue) {
  3538.   // flow somehow has problems with directly declared definition object
  3539.   // when using Object.defineProperty, so we have to procedurally build up
  3540.   // the object here.
  3541.   var dataDef = {};
  3542.   dataDef.get = function () { return this._data };
  3543.   var propsDef = {};
  3544.   propsDef.get = function () { return this._props };
  3545.   {
  3546.     dataDef.set = function (newData) {
  3547.       warn(
  3548.         'Avoid replacing instance root $data. ' +
  3549.         'Use nested data properties instead.',
  3550.         this
  3551.       );
  3552.     };
  3553.     propsDef.set = function () {
  3554.       warn("$props is readonly.", this);
  3555.     };
  3556.   }
  3557.   Object.defineProperty(Vue.prototype, '$data', dataDef);
  3558.   Object.defineProperty(Vue.prototype, '$props', propsDef);
  3559.  
  3560.   Vue.prototype.$set = set;
  3561.   Vue.prototype.$delete = del;
  3562.  
  3563.   Vue.prototype.$watch = function (
  3564.     expOrFn,
  3565.     cb,
  3566.     options
  3567.   ) {
  3568.     var vm = this;
  3569.     if (isPlainObject(cb)) {
  3570.       return createWatcher(vm, expOrFn, cb, options)
  3571.     }
  3572.     options = options || {};
  3573.     options.user = true;
  3574.     var watcher = new Watcher(vm, expOrFn, cb, options);
  3575.     if (options.immediate) {
  3576.       cb.call(vm, watcher.value);
  3577.     }
  3578.     return function unwatchFn () {
  3579.       watcher.teardown();
  3580.     }
  3581.   };
  3582. }
  3583.  
  3584. /*  */
  3585.  
  3586. function initProvide (vm) {
  3587.   var provide = vm.$options.provide;
  3588.   if (provide) {
  3589.     vm._provided = typeof provide === 'function'
  3590.       ? provide.call(vm)
  3591.       : provide;
  3592.   }
  3593. }
  3594.  
  3595. function initInjections (vm) {
  3596.   var result = resolveInject(vm.$options.inject, vm);
  3597.   if (result) {
  3598.     observerState.shouldConvert = false;
  3599.     Object.keys(result).forEach(function (key) {
  3600.       /* istanbul ignore else */
  3601.       {
  3602.         defineReactive(vm, key, result[key], function () {
  3603.           warn(
  3604.             "Avoid mutating an injected value directly since the changes will be " +
  3605.             "overwritten whenever the provided component re-renders. " +
  3606.             "injection being mutated: \"" + key + "\"",
  3607.             vm
  3608.           );
  3609.         });
  3610.       }
  3611.     });
  3612.     observerState.shouldConvert = true;
  3613.   }
  3614. }
  3615.  
  3616. function resolveInject (inject, vm) {
  3617.   if (inject) {
  3618.     // inject is :any because flow is not smart enough to figure out cached
  3619.     var result = Object.create(null);
  3620.     var keys = hasSymbol
  3621.       ? Reflect.ownKeys(inject).filter(function (key) {
  3622.         /* istanbul ignore next */
  3623.         return Object.getOwnPropertyDescriptor(inject, key).enumerable
  3624.       })
  3625.       : Object.keys(inject);
  3626.  
  3627.     for (var i = 0; i < keys.length; i++) {
  3628.       var key = keys[i];
  3629.       var provideKey = inject[key].from;
  3630.       var source = vm;
  3631.       while (source) {
  3632.         if (source._provided && provideKey in source._provided) {
  3633.           result[key] = source._provided[provideKey];
  3634.           break
  3635.         }
  3636.         source = source.$parent;
  3637.       }
  3638.       if (!source) {
  3639.         if ('default' in inject[key]) {
  3640.           var provideDefault = inject[key].default;
  3641.           result[key] = typeof provideDefault === 'function'
  3642.             ? provideDefault.call(vm)
  3643.             : provideDefault;
  3644.         } else {
  3645.           warn(("Injection \"" + key + "\" not found"), vm);
  3646.         }
  3647.       }
  3648.     }
  3649.     return result
  3650.   }
  3651. }
  3652.  
  3653. /*  */
  3654.  
  3655. /**
  3656.  * Runtime helper for rendering v-for lists.
  3657.  */
  3658. function renderList (
  3659.   val,
  3660.   render
  3661. ) {
  3662.   var ret, i, l, keys, key;
  3663.   if (Array.isArray(val) || typeof val === 'string') {
  3664.     ret = new Array(val.length);
  3665.     for (i = 0, l = val.length; i < l; i++) {
  3666.       ret[i] = render(val[i], i);
  3667.     }
  3668.   } else if (typeof val === 'number') {
  3669.     ret = new Array(val);
  3670.     for (i = 0; i < val; i++) {
  3671.       ret[i] = render(i + 1, i);
  3672.     }
  3673.   } else if (isObject(val)) {
  3674.     keys = Object.keys(val);
  3675.     ret = new Array(keys.length);
  3676.     for (i = 0, l = keys.length; i < l; i++) {
  3677.       key = keys[i];
  3678.       ret[i] = render(val[key], key, i);
  3679.     }
  3680.   }
  3681.   if (isDef(ret)) {
  3682.     (ret)._isVList = true;
  3683.   }
  3684.   return ret
  3685. }
  3686.  
  3687. /*  */
  3688.  
  3689. /**
  3690.  * Runtime helper for rendering <slot>
  3691.  */
  3692. function renderSlot (
  3693.   name,
  3694.   fallback,
  3695.   props,
  3696.   bindObject
  3697. ) {
  3698.   var scopedSlotFn = this.$scopedSlots[name];
  3699.   var nodes;
  3700.   if (scopedSlotFn) { // scoped slot
  3701.     props = props || {};
  3702.     if (bindObject) {
  3703.       if ("development" !== 'production' && !isObject(bindObject)) {
  3704.         warn(
  3705.           'slot v-bind without argument expects an Object',
  3706.           this
  3707.         );
  3708.       }
  3709.       props = extend(extend({}, bindObject), props);
  3710.     }
  3711.     nodes = scopedSlotFn(props) || fallback;
  3712.   } else {
  3713.     var slotNodes = this.$slots[name];
  3714.     // warn duplicate slot usage
  3715.     if (slotNodes) {
  3716.       if ("development" !== 'production' && slotNodes._rendered) {
  3717.         warn(
  3718.           "Duplicate presence of slot \"" + name + "\" found in the same render tree " +
  3719.           "- this will likely cause render errors.",
  3720.           this
  3721.         );
  3722.       }
  3723.       slotNodes._rendered = true;
  3724.     }
  3725.     nodes = slotNodes || fallback;
  3726.   }
  3727.  
  3728.   var target = props && props.slot;
  3729.   if (target) {
  3730.     return this.$createElement('template', { slot: target }, nodes)
  3731.   } else {
  3732.     return nodes
  3733.   }
  3734. }
  3735.  
  3736. /*  */
  3737.  
  3738. /**
  3739.  * Runtime helper for resolving filters
  3740.  */
  3741. function resolveFilter (id) {
  3742.   return resolveAsset(this.$options, 'filters', id, true) || identity
  3743. }
  3744.  
  3745. /*  */
  3746.  
  3747. /**
  3748.  * Runtime helper for checking keyCodes from config.
  3749.  * exposed as Vue.prototype._k
  3750.  * passing in eventKeyName as last argument separately for backwards compat
  3751.  */
  3752. function checkKeyCodes (
  3753.   eventKeyCode,
  3754.   key,
  3755.   builtInAlias,
  3756.   eventKeyName
  3757. ) {
  3758.   var keyCodes = config.keyCodes[key] || builtInAlias;
  3759.   if (keyCodes) {
  3760.     if (Array.isArray(keyCodes)) {
  3761.       return keyCodes.indexOf(eventKeyCode) === -1
  3762.     } else {
  3763.       return keyCodes !== eventKeyCode
  3764.     }
  3765.   } else if (eventKeyName) {
  3766.     return hyphenate(eventKeyName) !== key
  3767.   }
  3768. }
  3769.  
  3770. /*  */
  3771.  
  3772. /**
  3773.  * Runtime helper for merging v-bind="object" into a VNode's data.
  3774.  */
  3775. function bindObjectProps (
  3776.   data,
  3777.   tag,
  3778.   value,
  3779.   asProp,
  3780.   isSync
  3781. ) {
  3782.   if (value) {
  3783.     if (!isObject(value)) {
  3784.       "development" !== 'production' && warn(
  3785.         'v-bind without argument expects an Object or Array value',
  3786.         this
  3787.       );
  3788.     } else {
  3789.       if (Array.isArray(value)) {
  3790.         value = toObject(value);
  3791.       }
  3792.       var hash;
  3793.       var loop = function ( key ) {
  3794.         if (
  3795.           key === 'class' ||
  3796.           key === 'style' ||
  3797.           isReservedAttribute(key)
  3798.         ) {
  3799.           hash = data;
  3800.         } else {
  3801.           var type = data.attrs && data.attrs.type;
  3802.           hash = asProp || config.mustUseProp(tag, type, key)
  3803.             ? data.domProps || (data.domProps = {})
  3804.             : data.attrs || (data.attrs = {});
  3805.         }
  3806.         if (!(key in hash)) {
  3807.           hash[key] = value[key];
  3808.  
  3809.           if (isSync) {
  3810.             var on = data.on || (data.on = {});
  3811.             on[("update:" + key)] = function ($event) {
  3812.               value[key] = $event;
  3813.             };
  3814.           }
  3815.         }
  3816.       };
  3817.  
  3818.       for (var key in value) loop( key );
  3819.     }
  3820.   }
  3821.   return data
  3822. }
  3823.  
  3824. /*  */
  3825.  
  3826. /**
  3827.  * Runtime helper for rendering static trees.
  3828.  */
  3829. function renderStatic (
  3830.   index,
  3831.   isInFor
  3832. ) {
  3833.   var cached = this._staticTrees || (this._staticTrees = []);
  3834.   var tree = cached[index];
  3835.   // if has already-rendered static tree and not inside v-for,
  3836.   // we can reuse the same tree by doing a shallow clone.
  3837.   if (tree && !isInFor) {
  3838.     return Array.isArray(tree)
  3839.       ? cloneVNodes(tree)
  3840.       : cloneVNode(tree)
  3841.   }
  3842.   // otherwise, render a fresh tree.
  3843.   tree = cached[index] = this.$options.staticRenderFns[index].call(
  3844.     this._renderProxy,
  3845.     null,
  3846.     this // for render fns generated for functional component templates
  3847.   );
  3848.   markStatic(tree, ("__static__" + index), false);
  3849.   return tree
  3850. }
  3851.  
  3852. /**
  3853.  * Runtime helper for v-once.
  3854.  * Effectively it means marking the node as static with a unique key.
  3855.  */
  3856. function markOnce (
  3857.   tree,
  3858.   index,
  3859.   key
  3860. ) {
  3861.   markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
  3862.   return tree
  3863. }
  3864.  
  3865. function markStatic (
  3866.   tree,
  3867.   key,
  3868.   isOnce
  3869. ) {
  3870.   if (Array.isArray(tree)) {
  3871.     for (var i = 0; i < tree.length; i++) {
  3872.       if (tree[i] && typeof tree[i] !== 'string') {
  3873.         markStaticNode(tree[i], (key + "_" + i), isOnce);
  3874.       }
  3875.     }
  3876.   } else {
  3877.     markStaticNode(tree, key, isOnce);
  3878.   }
  3879. }
  3880.  
  3881. function markStaticNode (node, key, isOnce) {
  3882.   node.isStatic = true;
  3883.   node.key = key;
  3884.   node.isOnce = isOnce;
  3885. }
  3886.  
  3887. /*  */
  3888.  
  3889. function bindObjectListeners (data, value) {
  3890.   if (value) {
  3891.     if (!isPlainObject(value)) {
  3892.       "development" !== 'production' && warn(
  3893.         'v-on without argument expects an Object value',
  3894.         this
  3895.       );
  3896.     } else {
  3897.       var on = data.on = data.on ? extend({}, data.on) : {};
  3898.       for (var key in value) {
  3899.         var existing = on[key];
  3900.         var ours = value[key];
  3901.         on[key] = existing ? [].concat(existing, ours) : ours;
  3902.       }
  3903.     }
  3904.   }
  3905.   return data
  3906. }
  3907.  
  3908. /*  */
  3909.  
  3910. function installRenderHelpers (target) {
  3911.   target._o = markOnce;
  3912.   target._n = toNumber;
  3913.   target._s = toString;
  3914.   target._l = renderList;
  3915.   target._t = renderSlot;
  3916.   target._q = looseEqual;
  3917.   target._i = looseIndexOf;
  3918.   target._m = renderStatic;
  3919.   target._f = resolveFilter;
  3920.   target._k = checkKeyCodes;
  3921.   target._b = bindObjectProps;
  3922.   target._v = createTextVNode;
  3923.   target._e = createEmptyVNode;
  3924.   target._u = resolveScopedSlots;
  3925.   target._g = bindObjectListeners;
  3926. }
  3927.  
  3928. /*  */
  3929.  
  3930. function FunctionalRenderContext (
  3931.   data,
  3932.   props,
  3933.   children,
  3934.   parent,
  3935.   Ctor
  3936. ) {
  3937.   var options = Ctor.options;
  3938.   this.data = data;
  3939.   this.props = props;
  3940.   this.children = children;
  3941.   this.parent = parent;
  3942.   this.listeners = data.on || emptyObject;
  3943.   this.injections = resolveInject(options.inject, parent);
  3944.   this.slots = function () { return resolveSlots(children, parent); };
  3945.  
  3946.   // ensure the createElement function in functional components
  3947.   // gets a unique context - this is necessary for correct named slot check
  3948.   var contextVm = Object.create(parent);
  3949.   var isCompiled = isTrue(options._compiled);
  3950.   var needNormalization = !isCompiled;
  3951.  
  3952.   // support for compiled functional template
  3953.   if (isCompiled) {
  3954.     // exposing $options for renderStatic()
  3955.     this.$options = options;
  3956.     // pre-resolve slots for renderSlot()
  3957.     this.$slots = this.slots();
  3958.     this.$scopedSlots = data.scopedSlots || emptyObject;
  3959.   }
  3960.  
  3961.   if (options._scopeId) {
  3962.     this._c = function (a, b, c, d) {
  3963.       var vnode = createElement(contextVm, a, b, c, d, needNormalization);
  3964.       if (vnode) {
  3965.         vnode.fnScopeId = options._scopeId;
  3966.         vnode.fnContext = parent;
  3967.       }
  3968.       return vnode
  3969.     };
  3970.   } else {
  3971.     this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
  3972.   }
  3973. }
  3974.  
  3975. installRenderHelpers(FunctionalRenderContext.prototype);
  3976.  
  3977. function createFunctionalComponent (
  3978.   Ctor,
  3979.   propsData,
  3980.   data,
  3981.   contextVm,
  3982.   children
  3983. ) {
  3984.   var options = Ctor.options;
  3985.   var props = {};
  3986.   var propOptions = options.props;
  3987.   if (isDef(propOptions)) {
  3988.     for (var key in propOptions) {
  3989.       props[key] = validateProp(key, propOptions, propsData || emptyObject);
  3990.     }
  3991.   } else {
  3992.     if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
  3993.     if (isDef(data.props)) { mergeProps(props, data.props); }
  3994.   }
  3995.  
  3996.   var renderContext = new FunctionalRenderContext(
  3997.     data,
  3998.     props,
  3999.     children,
  4000.     contextVm,
  4001.     Ctor
  4002.   );
  4003.  
  4004.   var vnode = options.render.call(null, renderContext._c, renderContext);
  4005.  
  4006.   if (vnode instanceof VNode) {
  4007.     vnode.fnContext = contextVm;
  4008.     vnode.fnOptions = options;
  4009.     if (data.slot) {
  4010.       (vnode.data || (vnode.data = {})).slot = data.slot;
  4011.     }
  4012.   }
  4013.  
  4014.   return vnode
  4015. }
  4016.  
  4017. function mergeProps (to, from) {
  4018.   for (var key in from) {
  4019.     to[camelize(key)] = from[key];
  4020.   }
  4021. }
  4022.  
  4023. /*  */
  4024.  
  4025.  
  4026.  
  4027.  
  4028. // Register the component hook to weex native render engine.
  4029. // The hook will be triggered by native, not javascript.
  4030.  
  4031.  
  4032. // Updates the state of the component to weex native render engine.
  4033.  
  4034. /*  */
  4035.  
  4036. // https://github.com/Hanks10100/weex-native-directive/tree/master/component
  4037.  
  4038. // listening on native callback
  4039.  
  4040. /*  */
  4041.  
  4042. /*  */
  4043.  
  4044. // hooks to be invoked on component VNodes during patch
  4045. var componentVNodeHooks = {
  4046.   init: function init (
  4047.     vnode,
  4048.     hydrating,
  4049.     parentElm,
  4050.     refElm
  4051.   ) {
  4052.     if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
  4053.       var child = vnode.componentInstance = createComponentInstanceForVnode(
  4054.         vnode,
  4055.         activeInstance,
  4056.         parentElm,
  4057.         refElm
  4058.       );
  4059.       child.$mount(hydrating ? vnode.elm : undefined, hydrating);
  4060.     } else if (vnode.data.keepAlive) {
  4061.       // kept-alive components, treat as a patch
  4062.       var mountedNode = vnode; // work around flow
  4063.       componentVNodeHooks.prepatch(mountedNode, mountedNode);
  4064.     }
  4065.   },
  4066.  
  4067.   prepatch: function prepatch (oldVnode, vnode) {
  4068.     var options = vnode.componentOptions;
  4069.     var child = vnode.componentInstance = oldVnode.componentInstance;
  4070.     updateChildComponent(
  4071.       child,
  4072.       options.propsData, // updated props
  4073.       options.listeners, // updated listeners
  4074.       vnode, // new parent vnode
  4075.       options.children // new children
  4076.     );
  4077.   },
  4078.  
  4079.   insert: function insert (vnode) {
  4080.     var context = vnode.context;
  4081.     var componentInstance = vnode.componentInstance;
  4082.     if (!componentInstance._isMounted) {
  4083.       componentInstance._isMounted = true;
  4084.       callHook(componentInstance, 'mounted');
  4085.     }
  4086.     if (vnode.data.keepAlive) {
  4087.       if (context._isMounted) {
  4088.         // vue-router#1212
  4089.         // During updates, a kept-alive component's child components may
  4090.         // change, so directly walking the tree here may call activated hooks
  4091.         // on incorrect children. Instead we push them into a queue which will
  4092.         // be processed after the whole patch process ended.
  4093.         queueActivatedComponent(componentInstance);
  4094.       } else {
  4095.         activateChildComponent(componentInstance, true /* direct */);
  4096.       }
  4097.     }
  4098.   },
  4099.  
  4100.   destroy: function destroy (vnode) {
  4101.     var componentInstance = vnode.componentInstance;
  4102.     if (!componentInstance._isDestroyed) {
  4103.       if (!vnode.data.keepAlive) {
  4104.         componentInstance.$destroy();
  4105.       } else {
  4106.         deactivateChildComponent(componentInstance, true /* direct */);
  4107.       }
  4108.     }
  4109.   }
  4110. };
  4111.  
  4112. var hooksToMerge = Object.keys(componentVNodeHooks);
  4113.  
  4114. function createComponent (
  4115.   Ctor,
  4116.   data,
  4117.   context,
  4118.   children,
  4119.   tag
  4120. ) {
  4121.   if (isUndef(Ctor)) {
  4122.     return
  4123.   }
  4124.  
  4125.   var baseCtor = context.$options._base;
  4126.  
  4127.   // plain options object: turn it into a constructor
  4128.   if (isObject(Ctor)) {
  4129.     Ctor = baseCtor.extend(Ctor);
  4130.   }
  4131.  
  4132.   // if at this stage it's not a constructor or an async component factory,
  4133.   // reject.
  4134.   if (typeof Ctor !== 'function') {
  4135.     {
  4136.       warn(("Invalid Component definition: " + (String(Ctor))), context);
  4137.     }
  4138.     return
  4139.   }
  4140.  
  4141.   // async component
  4142.   var asyncFactory;
  4143.   if (isUndef(Ctor.cid)) {
  4144.     asyncFactory = Ctor;
  4145.     Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context);
  4146.     if (Ctor === undefined) {
  4147.       // return a placeholder node for async component, which is rendered
  4148.       // as a comment node but preserves all the raw information for the node.
  4149.       // the information will be used for async server-rendering and hydration.
  4150.       return createAsyncPlaceholder(
  4151.         asyncFactory,
  4152.         data,
  4153.         context,
  4154.         children,
  4155.         tag
  4156.       )
  4157.     }
  4158.   }
  4159.  
  4160.   data = data || {};
  4161.  
  4162.   // resolve constructor options in case global mixins are applied after
  4163.   // component constructor creation
  4164.   resolveConstructorOptions(Ctor);
  4165.  
  4166.   // transform component v-model data into props & events
  4167.   if (isDef(data.model)) {
  4168.     transformModel(Ctor.options, data);
  4169.   }
  4170.  
  4171.   // extract props
  4172.   var propsData = extractPropsFromVNodeData(data, Ctor, tag);
  4173.  
  4174.   // functional component
  4175.   if (isTrue(Ctor.options.functional)) {
  4176.     return createFunctionalComponent(Ctor, propsData, data, context, children)
  4177.   }
  4178.  
  4179.   // extract listeners, since these needs to be treated as
  4180.   // child component listeners instead of DOM listeners
  4181.   var listeners = data.on;
  4182.   // replace with listeners with .native modifier
  4183.   // so it gets processed during parent component patch.
  4184.   data.on = data.nativeOn;
  4185.  
  4186.   if (isTrue(Ctor.options.abstract)) {
  4187.     // abstract components do not keep anything
  4188.     // other than props & listeners & slot
  4189.  
  4190.     // work around flow
  4191.     var slot = data.slot;
  4192.     data = {};
  4193.     if (slot) {
  4194.       data.slot = slot;
  4195.     }
  4196.   }
  4197.  
  4198.   // merge component management hooks onto the placeholder node
  4199.   mergeHooks(data);
  4200.  
  4201.   // return a placeholder vnode
  4202.   var name = Ctor.options.name || tag;
  4203.   var vnode = new VNode(
  4204.     ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
  4205.     data, undefined, undefined, undefined, context,
  4206.     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
  4207.     asyncFactory
  4208.   );
  4209.  
  4210.   // Weex specific: invoke recycle-list optimized @render function for
  4211.   // extracting cell-slot template.
  4212.   // https://github.com/Hanks10100/weex-native-directive/tree/master/component
  4213.   /* istanbul ignore if */
  4214.   return vnode
  4215. }
  4216.  
  4217. function createComponentInstanceForVnode (
  4218.   vnode, // we know it's MountedComponentVNode but flow doesn't
  4219.   parent, // activeInstance in lifecycle state
  4220.   parentElm,
  4221.   refElm
  4222. ) {
  4223.   var options = {
  4224.     _isComponent: true,
  4225.     parent: parent,
  4226.     _parentVnode: vnode,
  4227.     _parentElm: parentElm || null,
  4228.     _refElm: refElm || null
  4229.   };
  4230.   // check inline-template render functions
  4231.   var inlineTemplate = vnode.data.inlineTemplate;
  4232.   if (isDef(inlineTemplate)) {
  4233.     options.render = inlineTemplate.render;
  4234.     options.staticRenderFns = inlineTemplate.staticRenderFns;
  4235.   }
  4236.   return new vnode.componentOptions.Ctor(options)
  4237. }
  4238.  
  4239. function mergeHooks (data) {
  4240.   if (!data.hook) {
  4241.     data.hook = {};
  4242.   }
  4243.   for (var i = 0; i < hooksToMerge.length; i++) {
  4244.     var key = hooksToMerge[i];
  4245.     var fromParent = data.hook[key];
  4246.     var ours = componentVNodeHooks[key];
  4247.     data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;
  4248.   }
  4249. }
  4250.  
  4251. function mergeHook$1 (one, two) {
  4252.   return function (a, b, c, d) {
  4253.     one(a, b, c, d);
  4254.     two(a, b, c, d);
  4255.   }
  4256. }
  4257.  
  4258. // transform component v-model info (value and callback) into
  4259. // prop and event handler respectively.
  4260. function transformModel (options, data) {
  4261.   var prop = (options.model && options.model.prop) || 'value';
  4262.   var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value;
  4263.   var on = data.on || (data.on = {});
  4264.   if (isDef(on[event])) {
  4265.     on[event] = [data.model.callback].concat(on[event]);
  4266.   } else {
  4267.     on[event] = data.model.callback;
  4268.   }
  4269. }
  4270.  
  4271. /*  */
  4272.  
  4273. var SIMPLE_NORMALIZE = 1;
  4274. var ALWAYS_NORMALIZE = 2;
  4275.  
  4276. // wrapper function for providing a more flexible interface
  4277. // without getting yelled at by flow
  4278. function createElement (
  4279.   context,
  4280.   tag,
  4281.   data,
  4282.   children,
  4283.   normalizationType,
  4284.   alwaysNormalize
  4285. ) {
  4286.   if (Array.isArray(data) || isPrimitive(data)) {
  4287.     normalizationType = children;
  4288.     children = data;
  4289.     data = undefined;
  4290.   }
  4291.   if (isTrue(alwaysNormalize)) {
  4292.     normalizationType = ALWAYS_NORMALIZE;
  4293.   }
  4294.   return _createElement(context, tag, data, children, normalizationType)
  4295. }
  4296.  
  4297. function _createElement (
  4298.   context,
  4299.   tag,
  4300.   data,
  4301.   children,
  4302.   normalizationType
  4303. ) {
  4304.   if (isDef(data) && isDef((data).__ob__)) {
  4305.     "development" !== 'production' && warn(
  4306.       "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
  4307.       'Always create fresh vnode data objects in each render!',
  4308.       context
  4309.     );
  4310.     return createEmptyVNode()
  4311.   }
  4312.   // object syntax in v-bind
  4313.   if (isDef(data) && isDef(data.is)) {
  4314.     tag = data.is;
  4315.   }
  4316.   if (!tag) {
  4317.     // in case of component :is set to falsy value
  4318.     return createEmptyVNode()
  4319.   }
  4320.   // warn against non-primitive key
  4321.   if ("development" !== 'production' &&
  4322.     isDef(data) && isDef(data.key) && !isPrimitive(data.key)
  4323.   ) {
  4324.     {
  4325.       warn(
  4326.         'Avoid using non-primitive value as key, ' +
  4327.         'use string/number value instead.',
  4328.         context
  4329.       );
  4330.     }
  4331.   }
  4332.   // support single function children as default scoped slot
  4333.   if (Array.isArray(children) &&
  4334.     typeof children[0] === 'function'
  4335.   ) {
  4336.     data = data || {};
  4337.     data.scopedSlots = { default: children[0] };
  4338.     children.length = 0;
  4339.   }
  4340.   if (normalizationType === ALWAYS_NORMALIZE) {
  4341.     children = normalizeChildren(children);
  4342.   } else if (normalizationType === SIMPLE_NORMALIZE) {
  4343.     children = simpleNormalizeChildren(children);
  4344.   }
  4345.   var vnode, ns;
  4346.   if (typeof tag === 'string') {
  4347.     var Ctor;
  4348.     ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
  4349.     if (config.isReservedTag(tag)) {
  4350.       // platform built-in elements
  4351.       vnode = new VNode(
  4352.         config.parsePlatformTagName(tag), data, children,
  4353.         undefined, undefined, context
  4354.       );
  4355.     } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
  4356.       // component
  4357.       vnode = createComponent(Ctor, data, context, children, tag);
  4358.     } else {
  4359.       // unknown or unlisted namespaced elements
  4360.       // check at runtime because it may get assigned a namespace when its
  4361.       // parent normalizes children
  4362.       vnode = new VNode(
  4363.         tag, data, children,
  4364.         undefined, undefined, context
  4365.       );
  4366.     }
  4367.   } else {
  4368.     // direct component options / constructor
  4369.     vnode = createComponent(tag, data, context, children);
  4370.   }
  4371.   if (isDef(vnode)) {
  4372.     if (ns) { applyNS(vnode, ns); }
  4373.     return vnode
  4374.   } else {
  4375.     return createEmptyVNode()
  4376.   }
  4377. }
  4378.  
  4379. function applyNS (vnode, ns, force) {
  4380.   vnode.ns = ns;
  4381.   if (vnode.tag === 'foreignObject') {
  4382.     // use default namespace inside foreignObject
  4383.     ns = undefined;
  4384.     force = true;
  4385.   }
  4386.   if (isDef(vnode.children)) {
  4387.     for (var i = 0, l = vnode.children.length; i < l; i++) {
  4388.       var child = vnode.children[i];
  4389.       if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) {
  4390.         applyNS(child, ns, force);
  4391.       }
  4392.     }
  4393.   }
  4394. }
  4395.  
  4396. /*  */
  4397.  
  4398. function initRender (vm) {
  4399.   vm._vnode = null; // the root of the child tree
  4400.   vm._staticTrees = null; // v-once cached trees
  4401.   var options = vm.$options;
  4402.   var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
  4403.   var renderContext = parentVnode && parentVnode.context;
  4404.   vm.$slots = resolveSlots(options._renderChildren, renderContext);
  4405.   vm.$scopedSlots = emptyObject;
  4406.   // bind the createElement fn to this instance
  4407.   // so that we get proper render context inside it.
  4408.   // args order: tag, data, children, normalizationType, alwaysNormalize
  4409.   // internal version is used by render functions compiled from templates
  4410.   vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
  4411.   // normalization is always applied for the public version, used in
  4412.   // user-written render functions.
  4413.   vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
  4414.  
  4415.   // $attrs & $listeners are exposed for easier HOC creation.
  4416.   // they need to be reactive so that HOCs using them are always updated
  4417.   var parentData = parentVnode && parentVnode.data;
  4418.  
  4419.   /* istanbul ignore else */
  4420.   {
  4421.     defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
  4422.       !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
  4423.     }, true);
  4424.     defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
  4425.       !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
  4426.     }, true);
  4427.   }
  4428. }
  4429.  
  4430. function renderMixin (Vue) {
  4431.   // install runtime convenience helpers
  4432.   installRenderHelpers(Vue.prototype);
  4433.  
  4434.   Vue.prototype.$nextTick = function (fn) {
  4435.     return nextTick(fn, this)
  4436.   };
  4437.  
  4438.   Vue.prototype._render = function () {
  4439.     var vm = this;
  4440.     var ref = vm.$options;
  4441.     var render = ref.render;
  4442.     var _parentVnode = ref._parentVnode;
  4443.  
  4444.     if (vm._isMounted) {
  4445.       // if the parent didn't update, the slot nodes will be the ones from
  4446.       // last render. They need to be cloned to ensure "freshness" for this render.
  4447.       for (var key in vm.$slots) {
  4448.         var slot = vm.$slots[key];
  4449.         // _rendered is a flag added by renderSlot, but may not be present
  4450.         // if the slot is passed from manually written render functions
  4451.         if (slot._rendered || (slot[0] && slot[0].elm)) {
  4452.           vm.$slots[key] = cloneVNodes(slot, true /* deep */);
  4453.         }
  4454.       }
  4455.     }
  4456.  
  4457.     vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject;
  4458.  
  4459.     // set parent vnode. this allows render functions to have access
  4460.     // to the data on the placeholder node.
  4461.     vm.$vnode = _parentVnode;
  4462.     // render self
  4463.     var vnode;
  4464.     try {
  4465.       vnode = render.call(vm._renderProxy, vm.$createElement);
  4466.     } catch (e) {
  4467.       handleError(e, vm, "render");
  4468.       // return error render result,
  4469.       // or previous vnode to prevent render error causing blank component
  4470.       /* istanbul ignore else */
  4471.       {
  4472.         if (vm.$options.renderError) {
  4473.           try {
  4474.             vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
  4475.           } catch (e) {
  4476.             handleError(e, vm, "renderError");
  4477.             vnode = vm._vnode;
  4478.           }
  4479.         } else {
  4480.           vnode = vm._vnode;
  4481.         }
  4482.       }
  4483.     }
  4484.     // return empty vnode in case the render function errored out
  4485.     if (!(vnode instanceof VNode)) {
  4486.       if ("development" !== 'production' && Array.isArray(vnode)) {
  4487.         warn(
  4488.           'Multiple root nodes returned from render function. Render function ' +
  4489.           'should return a single root node.',
  4490.           vm
  4491.         );
  4492.       }
  4493.       vnode = createEmptyVNode();
  4494.     }
  4495.     // set parent
  4496.     vnode.parent = _parentVnode;
  4497.     return vnode
  4498.   };
  4499. }
  4500.  
  4501. /*  */
  4502.  
  4503. var uid$1 = 0;
  4504.  
  4505. function initMixin (Vue) {
  4506.   Vue.prototype._init = function (options) {
  4507.     var vm = this;
  4508.     // a uid
  4509.     vm._uid = uid$1++;
  4510.  
  4511.     var startTag, endTag;
  4512.     /* istanbul ignore if */
  4513.     if ("development" !== 'production' && config.performance && mark) {
  4514.       startTag = "vue-perf-start:" + (vm._uid);
  4515.       endTag = "vue-perf-end:" + (vm._uid);
  4516.       mark(startTag);
  4517.     }
  4518.  
  4519.     // a flag to avoid this being observed
  4520.     vm._isVue = true;
  4521.     // merge options
  4522.     if (options && options._isComponent) {
  4523.       // optimize internal component instantiation
  4524.       // since dynamic options merging is pretty slow, and none of the
  4525.       // internal component options needs special treatment.
  4526.       initInternalComponent(vm, options);
  4527.     } else {
  4528.       vm.$options = mergeOptions(
  4529.         resolveConstructorOptions(vm.constructor),
  4530.         options || {},
  4531.         vm
  4532.       );
  4533.     }
  4534.     /* istanbul ignore else */
  4535.     {
  4536.       initProxy(vm);
  4537.     }
  4538.     // expose real self
  4539.     vm._self = vm;
  4540.     initLifecycle(vm);
  4541.     initEvents(vm);
  4542.     initRender(vm);
  4543.     callHook(vm, 'beforeCreate');
  4544.     initInjections(vm); // resolve injections before data/props
  4545.     initState(vm);
  4546.     initProvide(vm); // resolve provide after data/props
  4547.     callHook(vm, 'created');
  4548.  
  4549.     /* istanbul ignore if */
  4550.     if ("development" !== 'production' && config.performance && mark) {
  4551.       vm._name = formatComponentName(vm, false);
  4552.       mark(endTag);
  4553.       measure(("vue " + (vm._name) + " init"), startTag, endTag);
  4554.     }
  4555.  
  4556.     if (vm.$options.el) {
  4557.       vm.$mount(vm.$options.el);
  4558.     }
  4559.   };
  4560. }
  4561.  
  4562. function initInternalComponent (vm, options) {
  4563.   var opts = vm.$options = Object.create(vm.constructor.options);
  4564.   // doing this because it's faster than dynamic enumeration.
  4565.   var parentVnode = options._parentVnode;
  4566.   opts.parent = options.parent;
  4567.   opts._parentVnode = parentVnode;
  4568.   opts._parentElm = options._parentElm;
  4569.   opts._refElm = options._refElm;
  4570.  
  4571.   var vnodeComponentOptions = parentVnode.componentOptions;
  4572.   opts.propsData = vnodeComponentOptions.propsData;
  4573.   opts._parentListeners = vnodeComponentOptions.listeners;
  4574.   opts._renderChildren = vnodeComponentOptions.children;
  4575.   opts._componentTag = vnodeComponentOptions.tag;
  4576.  
  4577.   if (options.render) {
  4578.     opts.render = options.render;
  4579.     opts.staticRenderFns = options.staticRenderFns;
  4580.   }
  4581. }
  4582.  
  4583. function resolveConstructorOptions (Ctor) {
  4584.   var options = Ctor.options;
  4585.   if (Ctor.super) {
  4586.     var superOptions = resolveConstructorOptions(Ctor.super);
  4587.     var cachedSuperOptions = Ctor.superOptions;
  4588.     if (superOptions !== cachedSuperOptions) {
  4589.       // super option changed,
  4590.       // need to resolve new options.
  4591.       Ctor.superOptions = superOptions;
  4592.       // check if there are any late-modified/attached options (#4976)
  4593.       var modifiedOptions = resolveModifiedOptions(Ctor);
  4594.       // update base extend options
  4595.       if (modifiedOptions) {
  4596.         extend(Ctor.extendOptions, modifiedOptions);
  4597.       }
  4598.       options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
  4599.       if (options.name) {
  4600.         options.components[options.name] = Ctor;
  4601.       }
  4602.     }
  4603.   }
  4604.   return options
  4605. }
  4606.  
  4607. function resolveModifiedOptions (Ctor) {
  4608.   var modified;
  4609.   var latest = Ctor.options;
  4610.   var extended = Ctor.extendOptions;
  4611.   var sealed = Ctor.sealedOptions;
  4612.   for (var key in latest) {
  4613.     if (latest[key] !== sealed[key]) {
  4614.       if (!modified) { modified = {}; }
  4615.       modified[key] = dedupe(latest[key], extended[key], sealed[key]);
  4616.     }
  4617.   }
  4618.   return modified
  4619. }
  4620.  
  4621. function dedupe (latest, extended, sealed) {
  4622.   // compare latest and sealed to ensure lifecycle hooks won't be duplicated
  4623.   // between merges
  4624.   if (Array.isArray(latest)) {
  4625.     var res = [];
  4626.     sealed = Array.isArray(sealed) ? sealed : [sealed];
  4627.     extended = Array.isArray(extended) ? extended : [extended];
  4628.     for (var i = 0; i < latest.length; i++) {
  4629.       // push original options and not sealed options to exclude duplicated options
  4630.       if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
  4631.         res.push(latest[i]);
  4632.       }
  4633.     }
  4634.     return res
  4635.   } else {
  4636.     return latest
  4637.   }
  4638. }
  4639.  
  4640. function Vue$3 (options) {
  4641.   if ("development" !== 'production' &&
  4642.     !(this instanceof Vue$3)
  4643.   ) {
  4644.     warn('Vue is a constructor and should be called with the `new` keyword');
  4645.   }
  4646.   this._init(options);
  4647. }
  4648.  
  4649. initMixin(Vue$3);
  4650. stateMixin(Vue$3);
  4651. eventsMixin(Vue$3);
  4652. lifecycleMixin(Vue$3);
  4653. renderMixin(Vue$3);
  4654.  
  4655. /*  */
  4656.  
  4657. function initUse (Vue) {
  4658.   Vue.use = function (plugin) {
  4659.     var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
  4660.     if (installedPlugins.indexOf(plugin) > -1) {
  4661.       return this
  4662.     }
  4663.  
  4664.     // additional parameters
  4665.     var args = toArray(arguments, 1);
  4666.     args.unshift(this);
  4667.     if (typeof plugin.install === 'function') {
  4668.       plugin.install.apply(plugin, args);
  4669.     } else if (typeof plugin === 'function') {
  4670.       plugin.apply(null, args);
  4671.     }
  4672.     installedPlugins.push(plugin);
  4673.     return this
  4674.   };
  4675. }
  4676.  
  4677. /*  */
  4678.  
  4679. function initMixin$1 (Vue) {
  4680.   Vue.mixin = function (mixin) {
  4681.     this.options = mergeOptions(this.options, mixin);
  4682.     return this
  4683.   };
  4684. }
  4685.  
  4686. /*  */
  4687.  
  4688. function initExtend (Vue) {
  4689.   /**
  4690.    * Each instance constructor, including Vue, has a unique
  4691.    * cid. This enables us to create wrapped "child
  4692.    * constructors" for prototypal inheritance and cache them.
  4693.    */
  4694.   Vue.cid = 0;
  4695.   var cid = 1;
  4696.  
  4697.   /**
  4698.    * Class inheritance
  4699.    */
  4700.   Vue.extend = function (extendOptions) {
  4701.     extendOptions = extendOptions || {};
  4702.     var Super = this;
  4703.     var SuperId = Super.cid;
  4704.     var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
  4705.     if (cachedCtors[SuperId]) {
  4706.       return cachedCtors[SuperId]
  4707.     }
  4708.  
  4709.     var name = extendOptions.name || Super.options.name;
  4710.     if ("development" !== 'production' && name) {
  4711.       validateComponentName(name);
  4712.     }
  4713.  
  4714.     var Sub = function VueComponent (options) {
  4715.       this._init(options);
  4716.     };
  4717.     Sub.prototype = Object.create(Super.prototype);
  4718.     Sub.prototype.constructor = Sub;
  4719.     Sub.cid = cid++;
  4720.     Sub.options = mergeOptions(
  4721.       Super.options,
  4722.       extendOptions
  4723.     );
  4724.     Sub['super'] = Super;
  4725.  
  4726.     // For props and computed properties, we define the proxy getters on
  4727.     // the Vue instances at extension time, on the extended prototype. This
  4728.     // avoids Object.defineProperty calls for each instance created.
  4729.     if (Sub.options.props) {
  4730.       initProps$1(Sub);
  4731.     }
  4732.     if (Sub.options.computed) {
  4733.       initComputed$1(Sub);
  4734.     }
  4735.  
  4736.     // allow further extension/mixin/plugin usage
  4737.     Sub.extend = Super.extend;
  4738.     Sub.mixin = Super.mixin;
  4739.     Sub.use = Super.use;
  4740.  
  4741.     // create asset registers, so extended classes
  4742.     // can have their private assets too.
  4743.     ASSET_TYPES.forEach(function (type) {
  4744.       Sub[type] = Super[type];
  4745.     });
  4746.     // enable recursive self-lookup
  4747.     if (name) {
  4748.       Sub.options.components[name] = Sub;
  4749.     }
  4750.  
  4751.     // keep a reference to the super options at extension time.
  4752.     // later at instantiation we can check if Super's options have
  4753.     // been updated.
  4754.     Sub.superOptions = Super.options;
  4755.     Sub.extendOptions = extendOptions;
  4756.     Sub.sealedOptions = extend({}, Sub.options);
  4757.  
  4758.     // cache constructor
  4759.     cachedCtors[SuperId] = Sub;
  4760.     return Sub
  4761.   };
  4762. }
  4763.  
  4764. function initProps$1 (Comp) {
  4765.   var props = Comp.options.props;
  4766.   for (var key in props) {
  4767.     proxy(Comp.prototype, "_props", key);
  4768.   }
  4769. }
  4770.  
  4771. function initComputed$1 (Comp) {
  4772.   var computed = Comp.options.computed;
  4773.   for (var key in computed) {
  4774.     defineComputed(Comp.prototype, key, computed[key]);
  4775.   }
  4776. }
  4777.  
  4778. /*  */
  4779.  
  4780. function initAssetRegisters (Vue) {
  4781.   /**
  4782.    * Create asset registration methods.
  4783.    */
  4784.   ASSET_TYPES.forEach(function (type) {
  4785.     Vue[type] = function (
  4786.       id,
  4787.       definition
  4788.     ) {
  4789.       if (!definition) {
  4790.         return this.options[type + 's'][id]
  4791.       } else {
  4792.         /* istanbul ignore if */
  4793.         if ("development" !== 'production' && type === 'component') {
  4794.           validateComponentName(id);
  4795.         }
  4796.         if (type === 'component' && isPlainObject(definition)) {
  4797.           definition.name = definition.name || id;
  4798.           definition = this.options._base.extend(definition);
  4799.         }
  4800.         if (type === 'directive' && typeof definition === 'function') {
  4801.           definition = { bind: definition, update: definition };
  4802.         }
  4803.         this.options[type + 's'][id] = definition;
  4804.         return definition
  4805.       }
  4806.     };
  4807.   });
  4808. }
  4809.  
  4810. /*  */
  4811.  
  4812. function getComponentName (opts) {
  4813.   return opts && (opts.Ctor.options.name || opts.tag)
  4814. }
  4815.  
  4816. function matches (pattern, name) {
  4817.   if (Array.isArray(pattern)) {
  4818.     return pattern.indexOf(name) > -1
  4819.   } else if (typeof pattern === 'string') {
  4820.     return pattern.split(',').indexOf(name) > -1
  4821.   } else if (isRegExp(pattern)) {
  4822.     return pattern.test(name)
  4823.   }
  4824.   /* istanbul ignore next */
  4825.   return false
  4826. }
  4827.  
  4828. function pruneCache (keepAliveInstance, filter) {
  4829.   var cache = keepAliveInstance.cache;
  4830.   var keys = keepAliveInstance.keys;
  4831.   var _vnode = keepAliveInstance._vnode;
  4832.   for (var key in cache) {
  4833.     var cachedNode = cache[key];
  4834.     if (cachedNode) {
  4835.       var name = getComponentName(cachedNode.componentOptions);
  4836.       if (name && !filter(name)) {
  4837.         pruneCacheEntry(cache, key, keys, _vnode);
  4838.       }
  4839.     }
  4840.   }
  4841. }
  4842.  
  4843. function pruneCacheEntry (
  4844.   cache,
  4845.   key,
  4846.   keys,
  4847.   current
  4848. ) {
  4849.   var cached$$1 = cache[key];
  4850.   if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
  4851.     cached$$1.componentInstance.$destroy();
  4852.   }
  4853.   cache[key] = null;
  4854.   remove(keys, key);
  4855. }
  4856.  
  4857. var patternTypes = [String, RegExp, Array];
  4858.  
  4859. var KeepAlive = {
  4860.   name: 'keep-alive',
  4861.   abstract: true,
  4862.  
  4863.   props: {
  4864.     include: patternTypes,
  4865.     exclude: patternTypes,
  4866.     max: [String, Number]
  4867.   },
  4868.  
  4869.   created: function created () {
  4870.     this.cache = Object.create(null);
  4871.     this.keys = [];
  4872.   },
  4873.  
  4874.   destroyed: function destroyed () {
  4875.     var this$1 = this;
  4876.  
  4877.     for (var key in this$1.cache) {
  4878.       pruneCacheEntry(this$1.cache, key, this$1.keys);
  4879.     }
  4880.   },
  4881.  
  4882.   watch: {
  4883.     include: function include (val) {
  4884.       pruneCache(this, function (name) { return matches(val, name); });
  4885.     },
  4886.     exclude: function exclude (val) {
  4887.       pruneCache(this, function (name) { return !matches(val, name); });
  4888.     }
  4889.   },
  4890.  
  4891.   render: function render () {
  4892.     var slot = this.$slots.default;
  4893.     var vnode = getFirstComponentChild(slot);
  4894.     var componentOptions = vnode && vnode.componentOptions;
  4895.     if (componentOptions) {
  4896.       // check pattern
  4897.       var name = getComponentName(componentOptions);
  4898.       var ref = this;
  4899.       var include = ref.include;
  4900.       var exclude = ref.exclude;
  4901.       if (
  4902.         // not included
  4903.         (include && (!name || !matches(include, name))) ||
  4904.         // excluded
  4905.         (exclude && name && matches(exclude, name))
  4906.       ) {
  4907.         return vnode
  4908.       }
  4909.  
  4910.       var ref$1 = this;
  4911.       var cache = ref$1.cache;
  4912.       var keys = ref$1.keys;
  4913.       var key = vnode.key == null
  4914.         // same constructor may get registered as different local components
  4915.         // so cid alone is not enough (#3269)
  4916.         ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
  4917.         : vnode.key;
  4918.       if (cache[key]) {
  4919.         vnode.componentInstance = cache[key].componentInstance;
  4920.         // make current key freshest
  4921.         remove(keys, key);
  4922.         keys.push(key);
  4923.       } else {
  4924.         cache[key] = vnode;
  4925.         keys.push(key);
  4926.         // prune oldest entry
  4927.         if (this.max && keys.length > parseInt(this.max)) {
  4928.           pruneCacheEntry(cache, keys[0], keys, this._vnode);
  4929.         }
  4930.       }
  4931.  
  4932.       vnode.data.keepAlive = true;
  4933.     }
  4934.     return vnode || (slot && slot[0])
  4935.   }
  4936. };
  4937.  
  4938. var builtInComponents = {
  4939.   KeepAlive: KeepAlive
  4940. };
  4941.  
  4942. /*  */
  4943.  
  4944. function initGlobalAPI (Vue) {
  4945.   // config
  4946.   var configDef = {};
  4947.   configDef.get = function () { return config; };
  4948.   {
  4949.     configDef.set = function () {
  4950.       warn(
  4951.         'Do not replace the Vue.config object, set individual fields instead.'
  4952.       );
  4953.     };
  4954.   }
  4955.   Object.defineProperty(Vue, 'config', configDef);
  4956.  
  4957.   // exposed util methods.
  4958.   // NOTE: these are not considered part of the public API - avoid relying on
  4959.   // them unless you are aware of the risk.
  4960.   Vue.util = {
  4961.     warn: warn,
  4962.     extend: extend,
  4963.     mergeOptions: mergeOptions,
  4964.     defineReactive: defineReactive
  4965.   };
  4966.  
  4967.   Vue.set = set;
  4968.   Vue.delete = del;
  4969.   Vue.nextTick = nextTick;
  4970.  
  4971.   Vue.options = Object.create(null);
  4972.   ASSET_TYPES.forEach(function (type) {
  4973.     Vue.options[type + 's'] = Object.create(null);
  4974.   });
  4975.  
  4976.   // this is used to identify the "base" constructor to extend all plain-object
  4977.   // components with in Weex's multi-instance scenarios.
  4978.   Vue.options._base = Vue;
  4979.  
  4980.   extend(Vue.options.components, builtInComponents);
  4981.  
  4982.   initUse(Vue);
  4983.   initMixin$1(Vue);
  4984.   initExtend(Vue);
  4985.   initAssetRegisters(Vue);
  4986. }
  4987.  
  4988. initGlobalAPI(Vue$3);
  4989.  
  4990. Object.defineProperty(Vue$3.prototype, '$isServer', {
  4991.   get: isServerRendering
  4992. });
  4993.  
  4994. Object.defineProperty(Vue$3.prototype, '$ssrContext', {
  4995.   get: function get () {
  4996.     /* istanbul ignore next */
  4997.     return this.$vnode && this.$vnode.ssrContext
  4998.   }
  4999. });
  5000.  
  5001. Vue$3.version = '2.5.13';
  5002.  
  5003. /*  */
  5004.  
  5005. // these are reserved for web because they are directly compiled away
  5006. // during template compilation
  5007. var isReservedAttr = makeMap('style,class');
  5008.  
  5009. // attributes that should be using props for binding
  5010. var acceptValue = makeMap('input,textarea,option,select,progress');
  5011. var mustUseProp = function (tag, type, attr) {
  5012.   return (
  5013.     (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
  5014.     (attr === 'selected' && tag === 'option') ||
  5015.     (attr === 'checked' && tag === 'input') ||
  5016.     (attr === 'muted' && tag === 'video')
  5017.   )
  5018. };
  5019.  
  5020. var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
  5021.  
  5022. var isBooleanAttr = makeMap(
  5023.   'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
  5024.   'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
  5025.   'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
  5026.   'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
  5027.   'required,reversed,scoped,seamless,selected,sortable,translate,' +
  5028.   'truespeed,typemustmatch,visible'
  5029. );
  5030.  
  5031. var xlinkNS = 'http://www.w3.org/1999/xlink';
  5032.  
  5033. var isXlink = function (name) {
  5034.   return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
  5035. };
  5036.  
  5037. var getXlinkProp = function (name) {
  5038.   return isXlink(name) ? name.slice(6, name.length) : ''
  5039. };
  5040.  
  5041. var isFalsyAttrValue = function (val) {
  5042.   return val == null || val === false
  5043. };
  5044.  
  5045. /*  */
  5046.  
  5047. function genClassForVnode (vnode) {
  5048.   var data = vnode.data;
  5049.   var parentNode = vnode;
  5050.   var childNode = vnode;
  5051.   while (isDef(childNode.componentInstance)) {
  5052.     childNode = childNode.componentInstance._vnode;
  5053.     if (childNode && childNode.data) {
  5054.       data = mergeClassData(childNode.data, data);
  5055.     }
  5056.   }
  5057.   while (isDef(parentNode = parentNode.parent)) {
  5058.     if (parentNode && parentNode.data) {
  5059.       data = mergeClassData(data, parentNode.data);
  5060.     }
  5061.   }
  5062.   return renderClass(data.staticClass, data.class)
  5063. }
  5064.  
  5065. function mergeClassData (child, parent) {
  5066.   return {
  5067.     staticClass: concat(child.staticClass, parent.staticClass),
  5068.     class: isDef(child.class)
  5069.       ? [child.class, parent.class]
  5070.       : parent.class
  5071.   }
  5072. }
  5073.  
  5074. function renderClass (
  5075.   staticClass,
  5076.   dynamicClass
  5077. ) {
  5078.   if (isDef(staticClass) || isDef(dynamicClass)) {
  5079.     return concat(staticClass, stringifyClass(dynamicClass))
  5080.   }
  5081.   /* istanbul ignore next */
  5082.   return ''
  5083. }
  5084.  
  5085. function concat (a, b) {
  5086.   return a ? b ? (a + ' ' + b) : a : (b || '')
  5087. }
  5088.  
  5089. function stringifyClass (value) {
  5090.   if (Array.isArray(value)) {
  5091.     return stringifyArray(value)
  5092.   }
  5093.   if (isObject(value)) {
  5094.     return stringifyObject(value)
  5095.   }
  5096.   if (typeof value === 'string') {
  5097.     return value
  5098.   }
  5099.   /* istanbul ignore next */
  5100.   return ''
  5101. }
  5102.  
  5103. function stringifyArray (value) {
  5104.   var res = '';
  5105.   var stringified;
  5106.   for (var i = 0, l = value.length; i < l; i++) {
  5107.     if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
  5108.       if (res) { res += ' '; }
  5109.       res += stringified;
  5110.     }
  5111.   }
  5112.   return res
  5113. }
  5114.  
  5115. function stringifyObject (value) {
  5116.   var res = '';
  5117.   for (var key in value) {
  5118.     if (value[key]) {
  5119.       if (res) { res += ' '; }
  5120.       res += key;
  5121.     }
  5122.   }
  5123.   return res
  5124. }
  5125.  
  5126. /*  */
  5127.  
  5128. var namespaceMap = {
  5129.   svg: 'http://www.w3.org/2000/svg',
  5130.   math: 'http://www.w3.org/1998/Math/MathML'
  5131. };
  5132.  
  5133. var isHTMLTag = makeMap(
  5134.   'html,body,base,head,link,meta,style,title,' +
  5135.   'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
  5136.   'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
  5137.   'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
  5138.   's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
  5139.   'embed,object,param,source,canvas,script,noscript,del,ins,' +
  5140.   'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
  5141.   'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
  5142.   'output,progress,select,textarea,' +
  5143.   'details,dialog,menu,menuitem,summary,' +
  5144.   'content,element,shadow,template,blockquote,iframe,tfoot'
  5145. );
  5146.  
  5147. // this map is intentionally selective, only covering SVG elements that may
  5148. // contain child elements.
  5149. var isSVG = makeMap(
  5150.   'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
  5151.   'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
  5152.   'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
  5153.   true
  5154. );
  5155.  
  5156. var isPreTag = function (tag) { return tag === 'pre'; };
  5157.  
  5158. var isReservedTag = function (tag) {
  5159.   return isHTMLTag(tag) || isSVG(tag)
  5160. };
  5161.  
  5162. function getTagNamespace (tag) {
  5163.   if (isSVG(tag)) {
  5164.     return 'svg'
  5165.   }
  5166.   // basic support for MathML
  5167.   // note it doesn't support other MathML elements being component roots
  5168.   if (tag === 'math') {
  5169.     return 'math'
  5170.   }
  5171. }
  5172.  
  5173. var unknownElementCache = Object.create(null);
  5174. function isUnknownElement (tag) {
  5175.   /* istanbul ignore if */
  5176.   if (!inBrowser) {
  5177.     return true
  5178.   }
  5179.   if (isReservedTag(tag)) {
  5180.     return false
  5181.   }
  5182.   tag = tag.toLowerCase();
  5183.   /* istanbul ignore if */
  5184.   if (unknownElementCache[tag] != null) {
  5185.     return unknownElementCache[tag]
  5186.   }
  5187.   var el = document.createElement(tag);
  5188.   if (tag.indexOf('-') > -1) {
  5189.     // http://stackoverflow.com/a/28210364/1070244
  5190.     return (unknownElementCache[tag] = (
  5191.       el.constructor === window.HTMLUnknownElement ||
  5192.       el.constructor === window.HTMLElement
  5193.     ))
  5194.   } else {
  5195.     return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
  5196.   }
  5197. }
  5198.  
  5199. var isTextInputType = makeMap('text,number,password,search,email,tel,url');
  5200.  
  5201. /*  */
  5202.  
  5203. /**
  5204.  * Query an element selector if it's not an element already.
  5205.  */
  5206. function query (el) {
  5207.   if (typeof el === 'string') {
  5208.     var selected = document.querySelector(el);
  5209.     if (!selected) {
  5210.       "development" !== 'production' && warn(
  5211.         'Cannot find element: ' + el
  5212.       );
  5213.       return document.createElement('div')
  5214.     }
  5215.     return selected
  5216.   } else {
  5217.     return el
  5218.   }
  5219. }
  5220.  
  5221. /*  */
  5222.  
  5223. function createElement$1 (tagName, vnode) {
  5224.   var elm = document.createElement(tagName);
  5225.   if (tagName !== 'select') {
  5226.     return elm
  5227.   }
  5228.   // false or null will remove the attribute but undefined will not
  5229.   if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
  5230.     elm.setAttribute('multiple', 'multiple');
  5231.   }
  5232.   return elm
  5233. }
  5234.  
  5235. function createElementNS (namespace, tagName) {
  5236.   return document.createElementNS(namespaceMap[namespace], tagName)
  5237. }
  5238.  
  5239. function createTextNode (text) {
  5240.   return document.createTextNode(text)
  5241. }
  5242.  
  5243. function createComment (text) {
  5244.   return document.createComment(text)
  5245. }
  5246.  
  5247. function insertBefore (parentNode, newNode, referenceNode) {
  5248.   parentNode.insertBefore(newNode, referenceNode);
  5249. }
  5250.  
  5251. function removeChild (node, child) {
  5252.   node.removeChild(child);
  5253. }
  5254.  
  5255. function appendChild (node, child) {
  5256.   node.appendChild(child);
  5257. }
  5258.  
  5259. function parentNode (node) {
  5260.   return node.parentNode
  5261. }
  5262.  
  5263. function nextSibling (node) {
  5264.   return node.nextSibling
  5265. }
  5266.  
  5267. function tagName (node) {
  5268.   return node.tagName
  5269. }
  5270.  
  5271. function setTextContent (node, text) {
  5272.   node.textContent = text;
  5273. }
  5274.  
  5275. function setAttribute (node, key, val) {
  5276.   node.setAttribute(key, val);
  5277. }
  5278.  
  5279.  
  5280. var nodeOps = Object.freeze({
  5281. 	createElement: createElement$1,
  5282. 	createElementNS: createElementNS,
  5283. 	createTextNode: createTextNode,
  5284. 	createComment: createComment,
  5285. 	insertBefore: insertBefore,
  5286. 	removeChild: removeChild,
  5287. 	appendChild: appendChild,
  5288. 	parentNode: parentNode,
  5289. 	nextSibling: nextSibling,
  5290. 	tagName: tagName,
  5291. 	setTextContent: setTextContent,
  5292. 	setAttribute: setAttribute
  5293. });
  5294.  
  5295. /*  */
  5296.  
  5297. var ref = {
  5298.   create: function create (_, vnode) {
  5299.     registerRef(vnode);
  5300.   },
  5301.   update: function update (oldVnode, vnode) {
  5302.     if (oldVnode.data.ref !== vnode.data.ref) {
  5303.       registerRef(oldVnode, true);
  5304.       registerRef(vnode);
  5305.     }
  5306.   },
  5307.   destroy: function destroy (vnode) {
  5308.     registerRef(vnode, true);
  5309.   }
  5310. };
  5311.  
  5312. function registerRef (vnode, isRemoval) {
  5313.   var key = vnode.data.ref;
  5314.   if (!key) { return }
  5315.  
  5316.   var vm = vnode.context;
  5317.   var ref = vnode.componentInstance || vnode.elm;
  5318.   var refs = vm.$refs;
  5319.   if (isRemoval) {
  5320.     if (Array.isArray(refs[key])) {
  5321.       remove(refs[key], ref);
  5322.     } else if (refs[key] === ref) {
  5323.       refs[key] = undefined;
  5324.     }
  5325.   } else {
  5326.     if (vnode.data.refInFor) {
  5327.       if (!Array.isArray(refs[key])) {
  5328.         refs[key] = [ref];
  5329.       } else if (refs[key].indexOf(ref) < 0) {
  5330.         // $flow-disable-line
  5331.         refs[key].push(ref);
  5332.       }
  5333.     } else {
  5334.       refs[key] = ref;
  5335.     }
  5336.   }
  5337. }
  5338.  
  5339. /**
  5340.  * Virtual DOM patching algorithm based on Snabbdom by
  5341.  * Simon Friis Vindum (@paldepind)
  5342.  * Licensed under the MIT License
  5343.  * https://github.com/paldepind/snabbdom/blob/master/LICENSE
  5344.  *
  5345.  * modified by Evan You (@yyx990803)
  5346.  *
  5347.  * Not type-checking this because this file is perf-critical and the cost
  5348.  * of making flow understand it is not worth it.
  5349.  */
  5350.  
  5351. var emptyNode = new VNode('', {}, []);
  5352.  
  5353. var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
  5354.  
  5355. function sameVnode (a, b) {
  5356.   return (
  5357.     a.key === b.key && (
  5358.       (
  5359.         a.tag === b.tag &&
  5360.         a.isComment === b.isComment &&
  5361.         isDef(a.data) === isDef(b.data) &&
  5362.         sameInputType(a, b)
  5363.       ) || (
  5364.         isTrue(a.isAsyncPlaceholder) &&
  5365.         a.asyncFactory === b.asyncFactory &&
  5366.         isUndef(b.asyncFactory.error)
  5367.       )
  5368.     )
  5369.   )
  5370. }
  5371.  
  5372. function sameInputType (a, b) {
  5373.   if (a.tag !== 'input') { return true }
  5374.   var i;
  5375.   var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
  5376.   var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
  5377.   return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
  5378. }
  5379.  
  5380. function createKeyToOldIdx (children, beginIdx, endIdx) {
  5381.   var i, key;
  5382.   var map = {};
  5383.   for (i = beginIdx; i <= endIdx; ++i) {
  5384.     key = children[i].key;
  5385.     if (isDef(key)) { map[key] = i; }
  5386.   }
  5387.   return map
  5388. }
  5389.  
  5390. function createPatchFunction (backend) {
  5391.   var i, j;
  5392.   var cbs = {};
  5393.  
  5394.   var modules = backend.modules;
  5395.   var nodeOps = backend.nodeOps;
  5396.  
  5397.   for (i = 0; i < hooks.length; ++i) {
  5398.     cbs[hooks[i]] = [];
  5399.     for (j = 0; j < modules.length; ++j) {
  5400.       if (isDef(modules[j][hooks[i]])) {
  5401.         cbs[hooks[i]].push(modules[j][hooks[i]]);
  5402.       }
  5403.     }
  5404.   }
  5405.  
  5406.   function emptyNodeAt (elm) {
  5407.     return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
  5408.   }
  5409.  
  5410.   function createRmCb (childElm, listeners) {
  5411.     function remove () {
  5412.       if (--remove.listeners === 0) {
  5413.         removeNode(childElm);
  5414.       }
  5415.     }
  5416.     remove.listeners = listeners;
  5417.     return remove
  5418.   }
  5419.  
  5420.   function removeNode (el) {
  5421.     var parent = nodeOps.parentNode(el);
  5422.     // element may have already been removed due to v-html / v-text
  5423.     if (isDef(parent)) {
  5424.       nodeOps.removeChild(parent, el);
  5425.     }
  5426.   }
  5427.  
  5428.   function isUnknownElement$$1 (vnode, inVPre) {
  5429.     return (
  5430.       !inVPre &&
  5431.       !vnode.ns &&
  5432.       !(
  5433.         config.ignoredElements.length &&
  5434.         config.ignoredElements.some(function (ignore) {
  5435.           return isRegExp(ignore)
  5436.             ? ignore.test(vnode.tag)
  5437.             : ignore === vnode.tag
  5438.         })
  5439.       ) &&
  5440.       config.isUnknownElement(vnode.tag)
  5441.     )
  5442.   }
  5443.  
  5444.   var creatingElmInVPre = 0;
  5445.   function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {
  5446.     vnode.isRootInsert = !nested; // for transition enter check
  5447.     if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
  5448.       return
  5449.     }
  5450.  
  5451.     var data = vnode.data;
  5452.     var children = vnode.children;
  5453.     var tag = vnode.tag;
  5454.     if (isDef(tag)) {
  5455.       {
  5456.         if (data && data.pre) {
  5457.           creatingElmInVPre++;
  5458.         }
  5459.         if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
  5460.           warn(
  5461.             'Unknown custom element: <' + tag + '> - did you ' +
  5462.             'register the component correctly? For recursive components, ' +
  5463.             'make sure to provide the "name" option.',
  5464.             vnode.context
  5465.           );
  5466.         }
  5467.       }
  5468.       vnode.elm = vnode.ns
  5469.         ? nodeOps.createElementNS(vnode.ns, tag)
  5470.         : nodeOps.createElement(tag, vnode);
  5471.       setScope(vnode);
  5472.  
  5473.       /* istanbul ignore if */
  5474.       {
  5475.         createChildren(vnode, children, insertedVnodeQueue);
  5476.         if (isDef(data)) {
  5477.           invokeCreateHooks(vnode, insertedVnodeQueue);
  5478.         }
  5479.         insert(parentElm, vnode.elm, refElm);
  5480.       }
  5481.  
  5482.       if ("development" !== 'production' && data && data.pre) {
  5483.         creatingElmInVPre--;
  5484.       }
  5485.     } else if (isTrue(vnode.isComment)) {
  5486.       vnode.elm = nodeOps.createComment(vnode.text);
  5487.       insert(parentElm, vnode.elm, refElm);
  5488.     } else {
  5489.       vnode.elm = nodeOps.createTextNode(vnode.text);
  5490.       insert(parentElm, vnode.elm, refElm);
  5491.     }
  5492.   }
  5493.  
  5494.   function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
  5495.     var i = vnode.data;
  5496.     if (isDef(i)) {
  5497.       var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
  5498.       if (isDef(i = i.hook) && isDef(i = i.init)) {
  5499.         i(vnode, false /* hydrating */, parentElm, refElm);
  5500.       }
  5501.       // after calling the init hook, if the vnode is a child component
  5502.       // it should've created a child instance and mounted it. the child
  5503.       // component also has set the placeholder vnode's elm.
  5504.       // in that case we can just return the element and be done.
  5505.       if (isDef(vnode.componentInstance)) {
  5506.         initComponent(vnode, insertedVnodeQueue);
  5507.         if (isTrue(isReactivated)) {
  5508.           reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
  5509.         }
  5510.         return true
  5511.       }
  5512.     }
  5513.   }
  5514.  
  5515.   function initComponent (vnode, insertedVnodeQueue) {
  5516.     if (isDef(vnode.data.pendingInsert)) {
  5517.       insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
  5518.       vnode.data.pendingInsert = null;
  5519.     }
  5520.     vnode.elm = vnode.componentInstance.$el;
  5521.     if (isPatchable(vnode)) {
  5522.       invokeCreateHooks(vnode, insertedVnodeQueue);
  5523.       setScope(vnode);
  5524.     } else {
  5525.       // empty component root.
  5526.       // skip all element-related modules except for ref (#3455)
  5527.       registerRef(vnode);
  5528.       // make sure to invoke the insert hook
  5529.       insertedVnodeQueue.push(vnode);
  5530.     }
  5531.   }
  5532.  
  5533.   function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
  5534.     var i;
  5535.     // hack for #4339: a reactivated component with inner transition
  5536.     // does not trigger because the inner node's created hooks are not called
  5537.     // again. It's not ideal to involve module-specific logic in here but
  5538.     // there doesn't seem to be a better way to do it.
  5539.     var innerNode = vnode;
  5540.     while (innerNode.componentInstance) {
  5541.       innerNode = innerNode.componentInstance._vnode;
  5542.       if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
  5543.         for (i = 0; i < cbs.activate.length; ++i) {
  5544.           cbs.activate[i](emptyNode, innerNode);
  5545.         }
  5546.         insertedVnodeQueue.push(innerNode);
  5547.         break
  5548.       }
  5549.     }
  5550.     // unlike a newly created component,
  5551.     // a reactivated keep-alive component doesn't insert itself
  5552.     insert(parentElm, vnode.elm, refElm);
  5553.   }
  5554.  
  5555.   function insert (parent, elm, ref$$1) {
  5556.     if (isDef(parent)) {
  5557.       if (isDef(ref$$1)) {
  5558.         if (ref$$1.parentNode === parent) {
  5559.           nodeOps.insertBefore(parent, elm, ref$$1);
  5560.         }
  5561.       } else {
  5562.         nodeOps.appendChild(parent, elm);
  5563.       }
  5564.     }
  5565.   }
  5566.  
  5567.   function createChildren (vnode, children, insertedVnodeQueue) {
  5568.     if (Array.isArray(children)) {
  5569.       {
  5570.         checkDuplicateKeys(children);
  5571.       }
  5572.       for (var i = 0; i < children.length; ++i) {
  5573.         createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);
  5574.       }
  5575.     } else if (isPrimitive(vnode.text)) {
  5576.       nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
  5577.     }
  5578.   }
  5579.  
  5580.   function isPatchable (vnode) {
  5581.     while (vnode.componentInstance) {
  5582.       vnode = vnode.componentInstance._vnode;
  5583.     }
  5584.     return isDef(vnode.tag)
  5585.   }
  5586.  
  5587.   function invokeCreateHooks (vnode, insertedVnodeQueue) {
  5588.     for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
  5589.       cbs.create[i$1](emptyNode, vnode);
  5590.     }
  5591.     i = vnode.data.hook; // Reuse variable
  5592.     if (isDef(i)) {
  5593.       if (isDef(i.create)) { i.create(emptyNode, vnode); }
  5594.       if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
  5595.     }
  5596.   }
  5597.  
  5598.   // set scope id attribute for scoped CSS.
  5599.   // this is implemented as a special case to avoid the overhead
  5600.   // of going through the normal attribute patching process.
  5601.   function setScope (vnode) {
  5602.     var i;
  5603.     if (isDef(i = vnode.fnScopeId)) {
  5604.       nodeOps.setAttribute(vnode.elm, i, '');
  5605.     } else {
  5606.       var ancestor = vnode;
  5607.       while (ancestor) {
  5608.         if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
  5609.           nodeOps.setAttribute(vnode.elm, i, '');
  5610.         }
  5611.         ancestor = ancestor.parent;
  5612.       }
  5613.     }
  5614.     // for slot content they should also get the scopeId from the host instance.
  5615.     if (isDef(i = activeInstance) &&
  5616.       i !== vnode.context &&
  5617.       i !== vnode.fnContext &&
  5618.       isDef(i = i.$options._scopeId)
  5619.     ) {
  5620.       nodeOps.setAttribute(vnode.elm, i, '');
  5621.     }
  5622.   }
  5623.  
  5624.   function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
  5625.     for (; startIdx <= endIdx; ++startIdx) {
  5626.       createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);
  5627.     }
  5628.   }
  5629.  
  5630.   function invokeDestroyHook (vnode) {
  5631.     var i, j;
  5632.     var data = vnode.data;
  5633.     if (isDef(data)) {
  5634.       if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
  5635.       for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
  5636.     }
  5637.     if (isDef(i = vnode.children)) {
  5638.       for (j = 0; j < vnode.children.length; ++j) {
  5639.         invokeDestroyHook(vnode.children[j]);
  5640.       }
  5641.     }
  5642.   }
  5643.  
  5644.   function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
  5645.     for (; startIdx <= endIdx; ++startIdx) {
  5646.       var ch = vnodes[startIdx];
  5647.       if (isDef(ch)) {
  5648.         if (isDef(ch.tag)) {
  5649.           removeAndInvokeRemoveHook(ch);
  5650.           invokeDestroyHook(ch);
  5651.         } else { // Text node
  5652.           removeNode(ch.elm);
  5653.         }
  5654.       }
  5655.     }
  5656.   }
  5657.  
  5658.   function removeAndInvokeRemoveHook (vnode, rm) {
  5659.     if (isDef(rm) || isDef(vnode.data)) {
  5660.       var i;
  5661.       var listeners = cbs.remove.length + 1;
  5662.       if (isDef(rm)) {
  5663.         // we have a recursively passed down rm callback
  5664.         // increase the listeners count
  5665.         rm.listeners += listeners;
  5666.       } else {
  5667.         // directly removing
  5668.         rm = createRmCb(vnode.elm, listeners);
  5669.       }
  5670.       // recursively invoke hooks on child component root node
  5671.       if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
  5672.         removeAndInvokeRemoveHook(i, rm);
  5673.       }
  5674.       for (i = 0; i < cbs.remove.length; ++i) {
  5675.         cbs.remove[i](vnode, rm);
  5676.       }
  5677.       if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
  5678.         i(vnode, rm);
  5679.       } else {
  5680.         rm();
  5681.       }
  5682.     } else {
  5683.       removeNode(vnode.elm);
  5684.     }
  5685.   }
  5686.  
  5687.   function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
  5688.     var oldStartIdx = 0;
  5689.     var newStartIdx = 0;
  5690.     var oldEndIdx = oldCh.length - 1;
  5691.     var oldStartVnode = oldCh[0];
  5692.     var oldEndVnode = oldCh[oldEndIdx];
  5693.     var newEndIdx = newCh.length - 1;
  5694.     var newStartVnode = newCh[0];
  5695.     var newEndVnode = newCh[newEndIdx];
  5696.     var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
  5697.  
  5698.     // removeOnly is a special flag used only by <transition-group>
  5699.     // to ensure removed elements stay in correct relative positions
  5700.     // during leaving transitions
  5701.     var canMove = !removeOnly;
  5702.  
  5703.     {
  5704.       checkDuplicateKeys(newCh);
  5705.     }
  5706.  
  5707.     while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
  5708.       if (isUndef(oldStartVnode)) {
  5709.         oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
  5710.       } else if (isUndef(oldEndVnode)) {
  5711.         oldEndVnode = oldCh[--oldEndIdx];
  5712.       } else if (sameVnode(oldStartVnode, newStartVnode)) {
  5713.         patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
  5714.         oldStartVnode = oldCh[++oldStartIdx];
  5715.         newStartVnode = newCh[++newStartIdx];
  5716.       } else if (sameVnode(oldEndVnode, newEndVnode)) {
  5717.         patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
  5718.         oldEndVnode = oldCh[--oldEndIdx];
  5719.         newEndVnode = newCh[--newEndIdx];
  5720.       } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
  5721.         patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
  5722.         canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
  5723.         oldStartVnode = oldCh[++oldStartIdx];
  5724.         newEndVnode = newCh[--newEndIdx];
  5725.       } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
  5726.         patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
  5727.         canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
  5728.         oldEndVnode = oldCh[--oldEndIdx];
  5729.         newStartVnode = newCh[++newStartIdx];
  5730.       } else {
  5731.         if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
  5732.         idxInOld = isDef(newStartVnode.key)
  5733.           ? oldKeyToIdx[newStartVnode.key]
  5734.           : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
  5735.         if (isUndef(idxInOld)) { // New element
  5736.           createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
  5737.         } else {
  5738.           vnodeToMove = oldCh[idxInOld];
  5739.           if (sameVnode(vnodeToMove, newStartVnode)) {
  5740.             patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue);
  5741.             oldCh[idxInOld] = undefined;
  5742.             canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
  5743.           } else {
  5744.             // same key but different element. treat as new element
  5745.             createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
  5746.           }
  5747.         }
  5748.         newStartVnode = newCh[++newStartIdx];
  5749.       }
  5750.     }
  5751.     if (oldStartIdx > oldEndIdx) {
  5752.       refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
  5753.       addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
  5754.     } else if (newStartIdx > newEndIdx) {
  5755.       removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
  5756.     }
  5757.   }
  5758.  
  5759.   function checkDuplicateKeys (children) {
  5760.     var seenKeys = {};
  5761.     for (var i = 0; i < children.length; i++) {
  5762.       var vnode = children[i];
  5763.       var key = vnode.key;
  5764.       if (isDef(key)) {
  5765.         if (seenKeys[key]) {
  5766.           warn(
  5767.             ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
  5768.             vnode.context
  5769.           );
  5770.         } else {
  5771.           seenKeys[key] = true;
  5772.         }
  5773.       }
  5774.     }
  5775.   }
  5776.  
  5777.   function findIdxInOld (node, oldCh, start, end) {
  5778.     for (var i = start; i < end; i++) {
  5779.       var c = oldCh[i];
  5780.       if (isDef(c) && sameVnode(node, c)) { return i }
  5781.     }
  5782.   }
  5783.  
  5784.   function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
  5785.     if (oldVnode === vnode) {
  5786.       return
  5787.     }
  5788.  
  5789.     var elm = vnode.elm = oldVnode.elm;
  5790.  
  5791.     if (isTrue(oldVnode.isAsyncPlaceholder)) {
  5792.       if (isDef(vnode.asyncFactory.resolved)) {
  5793.         hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
  5794.       } else {
  5795.         vnode.isAsyncPlaceholder = true;
  5796.       }
  5797.       return
  5798.     }
  5799.  
  5800.     // reuse element for static trees.
  5801.     // note we only do this if the vnode is cloned -
  5802.     // if the new node is not cloned it means the render functions have been
  5803.     // reset by the hot-reload-api and we need to do a proper re-render.
  5804.     if (isTrue(vnode.isStatic) &&
  5805.       isTrue(oldVnode.isStatic) &&
  5806.       vnode.key === oldVnode.key &&
  5807.       (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
  5808.     ) {
  5809.       vnode.componentInstance = oldVnode.componentInstance;
  5810.       return
  5811.     }
  5812.  
  5813.     var i;
  5814.     var data = vnode.data;
  5815.     if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
  5816.       i(oldVnode, vnode);
  5817.     }
  5818.  
  5819.     var oldCh = oldVnode.children;
  5820.     var ch = vnode.children;
  5821.     if (isDef(data) && isPatchable(vnode)) {
  5822.       for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
  5823.       if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
  5824.     }
  5825.     if (isUndef(vnode.text)) {
  5826.       if (isDef(oldCh) && isDef(ch)) {
  5827.         if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
  5828.       } else if (isDef(ch)) {
  5829.         if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
  5830.         addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
  5831.       } else if (isDef(oldCh)) {
  5832.         removeVnodes(elm, oldCh, 0, oldCh.length - 1);
  5833.       } else if (isDef(oldVnode.text)) {
  5834.         nodeOps.setTextContent(elm, '');
  5835.       }
  5836.     } else if (oldVnode.text !== vnode.text) {
  5837.       nodeOps.setTextContent(elm, vnode.text);
  5838.     }
  5839.     if (isDef(data)) {
  5840.       if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
  5841.     }
  5842.   }
  5843.  
  5844.   function invokeInsertHook (vnode, queue, initial) {
  5845.     // delay insert hooks for component root nodes, invoke them after the
  5846.     // element is really inserted
  5847.     if (isTrue(initial) && isDef(vnode.parent)) {
  5848.       vnode.parent.data.pendingInsert = queue;
  5849.     } else {
  5850.       for (var i = 0; i < queue.length; ++i) {
  5851.         queue[i].data.hook.insert(queue[i]);
  5852.       }
  5853.     }
  5854.   }
  5855.  
  5856.   var hydrationBailed = false;
  5857.   // list of modules that can skip create hook during hydration because they
  5858.   // are already rendered on the client or has no need for initialization
  5859.   // Note: style is excluded because it relies on initial clone for future
  5860.   // deep updates (#7063).
  5861.   var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
  5862.  
  5863.   // Note: this is a browser-only function so we can assume elms are DOM nodes.
  5864.   function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
  5865.     var i;
  5866.     var tag = vnode.tag;
  5867.     var data = vnode.data;
  5868.     var children = vnode.children;
  5869.     inVPre = inVPre || (data && data.pre);
  5870.     vnode.elm = elm;
  5871.  
  5872.     if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
  5873.       vnode.isAsyncPlaceholder = true;
  5874.       return true
  5875.     }
  5876.     // assert node match
  5877.     {
  5878.       if (!assertNodeMatch(elm, vnode, inVPre)) {
  5879.         return false
  5880.       }
  5881.     }
  5882.     if (isDef(data)) {
  5883.       if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
  5884.       if (isDef(i = vnode.componentInstance)) {
  5885.         // child component. it should have hydrated its own tree.
  5886.         initComponent(vnode, insertedVnodeQueue);
  5887.         return true
  5888.       }
  5889.     }
  5890.     if (isDef(tag)) {
  5891.       if (isDef(children)) {
  5892.         // empty element, allow client to pick up and populate children
  5893.         if (!elm.hasChildNodes()) {
  5894.           createChildren(vnode, children, insertedVnodeQueue);
  5895.         } else {
  5896.           // v-html and domProps: innerHTML
  5897.           if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
  5898.             if (i !== elm.innerHTML) {
  5899.               /* istanbul ignore if */
  5900.               if ("development" !== 'production' &&
  5901.                 typeof console !== 'undefined' &&
  5902.                 !hydrationBailed
  5903.               ) {
  5904.                 hydrationBailed = true;
  5905.                 console.warn('Parent: ', elm);
  5906.                 console.warn('server innerHTML: ', i);
  5907.                 console.warn('client innerHTML: ', elm.innerHTML);
  5908.               }
  5909.               return false
  5910.             }
  5911.           } else {
  5912.             // iterate and compare children lists
  5913.             var childrenMatch = true;
  5914.             var childNode = elm.firstChild;
  5915.             for (var i$1 = 0; i$1 < children.length; i$1++) {
  5916.               if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
  5917.                 childrenMatch = false;
  5918.                 break
  5919.               }
  5920.               childNode = childNode.nextSibling;
  5921.             }
  5922.             // if childNode is not null, it means the actual childNodes list is
  5923.             // longer than the virtual children list.
  5924.             if (!childrenMatch || childNode) {
  5925.               /* istanbul ignore if */
  5926.               if ("development" !== 'production' &&
  5927.                 typeof console !== 'undefined' &&
  5928.                 !hydrationBailed
  5929.               ) {
  5930.                 hydrationBailed = true;
  5931.                 console.warn('Parent: ', elm);
  5932.                 console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
  5933.               }
  5934.               return false
  5935.             }
  5936.           }
  5937.         }
  5938.       }
  5939.       if (isDef(data)) {
  5940.         var fullInvoke = false;
  5941.         for (var key in data) {
  5942.           if (!isRenderedModule(key)) {
  5943.             fullInvoke = true;
  5944.             invokeCreateHooks(vnode, insertedVnodeQueue);
  5945.             break
  5946.           }
  5947.         }
  5948.         if (!fullInvoke && data['class']) {
  5949.           // ensure collecting deps for deep class bindings for future updates
  5950.           traverse(data['class']);
  5951.         }
  5952.       }
  5953.     } else if (elm.data !== vnode.text) {
  5954.       elm.data = vnode.text;
  5955.     }
  5956.     return true
  5957.   }
  5958.  
  5959.   function assertNodeMatch (node, vnode, inVPre) {
  5960.     if (isDef(vnode.tag)) {
  5961.       return vnode.tag.indexOf('vue-component') === 0 || (
  5962.         !isUnknownElement$$1(vnode, inVPre) &&
  5963.         vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
  5964.       )
  5965.     } else {
  5966.       return node.nodeType === (vnode.isComment ? 8 : 3)
  5967.     }
  5968.   }
  5969.  
  5970.   return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
  5971.     if (isUndef(vnode)) {
  5972.       if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
  5973.       return
  5974.     }
  5975.  
  5976.     var isInitialPatch = false;
  5977.     var insertedVnodeQueue = [];
  5978.  
  5979.     if (isUndef(oldVnode)) {
  5980.       // empty mount (likely as component), create new root element
  5981.       isInitialPatch = true;
  5982.       createElm(vnode, insertedVnodeQueue, parentElm, refElm);
  5983.     } else {
  5984.       var isRealElement = isDef(oldVnode.nodeType);
  5985.       if (!isRealElement && sameVnode(oldVnode, vnode)) {
  5986.         // patch existing root node
  5987.         patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);
  5988.       } else {
  5989.         if (isRealElement) {
  5990.           // mounting to a real element
  5991.           // check if this is server-rendered content and if we can perform
  5992.           // a successful hydration.
  5993.           if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
  5994.             oldVnode.removeAttribute(SSR_ATTR);
  5995.             hydrating = true;
  5996.           }
  5997.           if (isTrue(hydrating)) {
  5998.             if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
  5999.               invokeInsertHook(vnode, insertedVnodeQueue, true);
  6000.               return oldVnode
  6001.             } else {
  6002.               warn(
  6003.                 'The client-side rendered virtual DOM tree is not matching ' +
  6004.                 'server-rendered content. This is likely caused by incorrect ' +
  6005.                 'HTML markup, for example nesting block-level elements inside ' +
  6006.                 '<p>, or missing <tbody>. Bailing hydration and performing ' +
  6007.                 'full client-side render.'
  6008.               );
  6009.             }
  6010.           }
  6011.           // either not server-rendered, or hydration failed.
  6012.           // create an empty node and replace it
  6013.           oldVnode = emptyNodeAt(oldVnode);
  6014.         }
  6015.  
  6016.         // replacing existing element
  6017.         var oldElm = oldVnode.elm;
  6018.         var parentElm$1 = nodeOps.parentNode(oldElm);
  6019.  
  6020.         // create new node
  6021.         createElm(
  6022.           vnode,
  6023.           insertedVnodeQueue,
  6024.           // extremely rare edge case: do not insert if old element is in a
  6025.           // leaving transition. Only happens when combining transition +
  6026.           // keep-alive + HOCs. (#4590)
  6027.           oldElm._leaveCb ? null : parentElm$1,
  6028.           nodeOps.nextSibling(oldElm)
  6029.         );
  6030.  
  6031.         // update parent placeholder node element, recursively
  6032.         if (isDef(vnode.parent)) {
  6033.           var ancestor = vnode.parent;
  6034.           var patchable = isPatchable(vnode);
  6035.           while (ancestor) {
  6036.             for (var i = 0; i < cbs.destroy.length; ++i) {
  6037.               cbs.destroy[i](ancestor);
  6038.             }
  6039.             ancestor.elm = vnode.elm;
  6040.             if (patchable) {
  6041.               for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
  6042.                 cbs.create[i$1](emptyNode, ancestor);
  6043.               }
  6044.               // #6513
  6045.               // invoke insert hooks that may have been merged by create hooks.
  6046.               // e.g. for directives that uses the "inserted" hook.
  6047.               var insert = ancestor.data.hook.insert;
  6048.               if (insert.merged) {
  6049.                 // start at index 1 to avoid re-invoking component mounted hook
  6050.                 for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
  6051.                   insert.fns[i$2]();
  6052.                 }
  6053.               }
  6054.             } else {
  6055.               registerRef(ancestor);
  6056.             }
  6057.             ancestor = ancestor.parent;
  6058.           }
  6059.         }
  6060.  
  6061.         // destroy old node
  6062.         if (isDef(parentElm$1)) {
  6063.           removeVnodes(parentElm$1, [oldVnode], 0, 0);
  6064.         } else if (isDef(oldVnode.tag)) {
  6065.           invokeDestroyHook(oldVnode);
  6066.         }
  6067.       }
  6068.     }
  6069.  
  6070.     invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
  6071.     return vnode.elm
  6072.   }
  6073. }
  6074.  
  6075. /*  */
  6076.  
  6077. var directives = {
  6078.   create: updateDirectives,
  6079.   update: updateDirectives,
  6080.   destroy: function unbindDirectives (vnode) {
  6081.     updateDirectives(vnode, emptyNode);
  6082.   }
  6083. };
  6084.  
  6085. function updateDirectives (oldVnode, vnode) {
  6086.   if (oldVnode.data.directives || vnode.data.directives) {
  6087.     _update(oldVnode, vnode);
  6088.   }
  6089. }
  6090.  
  6091. function _update (oldVnode, vnode) {
  6092.   var isCreate = oldVnode === emptyNode;
  6093.   var isDestroy = vnode === emptyNode;
  6094.   var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
  6095.   var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
  6096.  
  6097.   var dirsWithInsert = [];
  6098.   var dirsWithPostpatch = [];
  6099.  
  6100.   var key, oldDir, dir;
  6101.   for (key in newDirs) {
  6102.     oldDir = oldDirs[key];
  6103.     dir = newDirs[key];
  6104.     if (!oldDir) {
  6105.       // new directive, bind
  6106.       callHook$1(dir, 'bind', vnode, oldVnode);
  6107.       if (dir.def && dir.def.inserted) {
  6108.         dirsWithInsert.push(dir);
  6109.       }
  6110.     } else {
  6111.       // existing directive, update
  6112.       dir.oldValue = oldDir.value;
  6113.       callHook$1(dir, 'update', vnode, oldVnode);
  6114.       if (dir.def && dir.def.componentUpdated) {
  6115.         dirsWithPostpatch.push(dir);
  6116.       }
  6117.     }
  6118.   }
  6119.  
  6120.   if (dirsWithInsert.length) {
  6121.     var callInsert = function () {
  6122.       for (var i = 0; i < dirsWithInsert.length; i++) {
  6123.         callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
  6124.       }
  6125.     };
  6126.     if (isCreate) {
  6127.       mergeVNodeHook(vnode, 'insert', callInsert);
  6128.     } else {
  6129.       callInsert();
  6130.     }
  6131.   }
  6132.  
  6133.   if (dirsWithPostpatch.length) {
  6134.     mergeVNodeHook(vnode, 'postpatch', function () {
  6135.       for (var i = 0; i < dirsWithPostpatch.length; i++) {
  6136.         callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
  6137.       }
  6138.     });
  6139.   }
  6140.  
  6141.   if (!isCreate) {
  6142.     for (key in oldDirs) {
  6143.       if (!newDirs[key]) {
  6144.         // no longer present, unbind
  6145.         callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
  6146.       }
  6147.     }
  6148.   }
  6149. }
  6150.  
  6151. var emptyModifiers = Object.create(null);
  6152.  
  6153. function normalizeDirectives$1 (
  6154.   dirs,
  6155.   vm
  6156. ) {
  6157.   var res = Object.create(null);
  6158.   if (!dirs) {
  6159.     // $flow-disable-line
  6160.     return res
  6161.   }
  6162.   var i, dir;
  6163.   for (i = 0; i < dirs.length; i++) {
  6164.     dir = dirs[i];
  6165.     if (!dir.modifiers) {
  6166.       // $flow-disable-line
  6167.       dir.modifiers = emptyModifiers;
  6168.     }
  6169.     res[getRawDirName(dir)] = dir;
  6170.     dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
  6171.   }
  6172.   // $flow-disable-line
  6173.   return res
  6174. }
  6175.  
  6176. function getRawDirName (dir) {
  6177.   return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
  6178. }
  6179.  
  6180. function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
  6181.   var fn = dir.def && dir.def[hook];
  6182.   if (fn) {
  6183.     try {
  6184.       fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
  6185.     } catch (e) {
  6186.       handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
  6187.     }
  6188.   }
  6189. }
  6190.  
  6191. var baseModules = [
  6192.   ref,
  6193.   directives
  6194. ];
  6195.  
  6196. /*  */
  6197.  
  6198. function updateAttrs (oldVnode, vnode) {
  6199.   var opts = vnode.componentOptions;
  6200.   if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
  6201.     return
  6202.   }
  6203.   if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
  6204.     return
  6205.   }
  6206.   var key, cur, old;
  6207.   var elm = vnode.elm;
  6208.   var oldAttrs = oldVnode.data.attrs || {};
  6209.   var attrs = vnode.data.attrs || {};
  6210.   // clone observed objects, as the user probably wants to mutate it
  6211.   if (isDef(attrs.__ob__)) {
  6212.     attrs = vnode.data.attrs = extend({}, attrs);
  6213.   }
  6214.  
  6215.   for (key in attrs) {
  6216.     cur = attrs[key];
  6217.     old = oldAttrs[key];
  6218.     if (old !== cur) {
  6219.       setAttr(elm, key, cur);
  6220.     }
  6221.   }
  6222.   // #4391: in IE9, setting type can reset value for input[type=radio]
  6223.   // #6666: IE/Edge forces progress value down to 1 before setting a max
  6224.   /* istanbul ignore if */
  6225.   if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
  6226.     setAttr(elm, 'value', attrs.value);
  6227.   }
  6228.   for (key in oldAttrs) {
  6229.     if (isUndef(attrs[key])) {
  6230.       if (isXlink(key)) {
  6231.         elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
  6232.       } else if (!isEnumeratedAttr(key)) {
  6233.         elm.removeAttribute(key);
  6234.       }
  6235.     }
  6236.   }
  6237. }
  6238.  
  6239. function setAttr (el, key, value) {
  6240.   if (isBooleanAttr(key)) {
  6241.     // set attribute for blank value
  6242.     // e.g. <option disabled>Select one</option>
  6243.     if (isFalsyAttrValue(value)) {
  6244.       el.removeAttribute(key);
  6245.     } else {
  6246.       // technically allowfullscreen is a boolean attribute for <iframe>,
  6247.       // but Flash expects a value of "true" when used on <embed> tag
  6248.       value = key === 'allowfullscreen' && el.tagName === 'EMBED'
  6249.         ? 'true'
  6250.         : key;
  6251.       el.setAttribute(key, value);
  6252.     }
  6253.   } else if (isEnumeratedAttr(key)) {
  6254.     el.setAttribute(key, isFalsyAttrValue(value) || value === 'false' ? 'false' : 'true');
  6255.   } else if (isXlink(key)) {
  6256.     if (isFalsyAttrValue(value)) {
  6257.       el.removeAttributeNS(xlinkNS, getXlinkProp(key));
  6258.     } else {
  6259.       el.setAttributeNS(xlinkNS, key, value);
  6260.     }
  6261.   } else {
  6262.     if (isFalsyAttrValue(value)) {
  6263.       el.removeAttribute(key);
  6264.     } else {
  6265.       // #7138: IE10 & 11 fires input event when setting placeholder on
  6266.       // <textarea>... block the first input event and remove the blocker
  6267.       // immediately.
  6268.       /* istanbul ignore if */
  6269.       if (
  6270.         isIE && !isIE9 &&
  6271.         el.tagName === 'TEXTAREA' &&
  6272.         key === 'placeholder' && !el.__ieph
  6273.       ) {
  6274.         var blocker = function (e) {
  6275.           e.stopImmediatePropagation();
  6276.           el.removeEventListener('input', blocker);
  6277.         };
  6278.         el.addEventListener('input', blocker);
  6279.         // $flow-disable-line
  6280.         el.__ieph = true; /* IE placeholder patched */
  6281.       }
  6282.       el.setAttribute(key, value);
  6283.     }
  6284.   }
  6285. }
  6286.  
  6287. var attrs = {
  6288.   create: updateAttrs,
  6289.   update: updateAttrs
  6290. };
  6291.  
  6292. /*  */
  6293.  
  6294. function updateClass (oldVnode, vnode) {
  6295.   var el = vnode.elm;
  6296.   var data = vnode.data;
  6297.   var oldData = oldVnode.data;
  6298.   if (
  6299.     isUndef(data.staticClass) &&
  6300.     isUndef(data.class) && (
  6301.       isUndef(oldData) || (
  6302.         isUndef(oldData.staticClass) &&
  6303.         isUndef(oldData.class)
  6304.       )
  6305.     )
  6306.   ) {
  6307.     return
  6308.   }
  6309.  
  6310.   var cls = genClassForVnode(vnode);
  6311.  
  6312.   // handle transition classes
  6313.   var transitionClass = el._transitionClasses;
  6314.   if (isDef(transitionClass)) {
  6315.     cls = concat(cls, stringifyClass(transitionClass));
  6316.   }
  6317.  
  6318.   // set the class
  6319.   if (cls !== el._prevClass) {
  6320.     el.setAttribute('class', cls);
  6321.     el._prevClass = cls;
  6322.   }
  6323. }
  6324.  
  6325. var klass = {
  6326.   create: updateClass,
  6327.   update: updateClass
  6328. };
  6329.  
  6330. /*  */
  6331.  
  6332. var validDivisionCharRE = /[\w).+\-_$\]]/;
  6333.  
  6334. function parseFilters (exp) {
  6335.   var inSingle = false;
  6336.   var inDouble = false;
  6337.   var inTemplateString = false;
  6338.   var inRegex = false;
  6339.   var curly = 0;
  6340.   var square = 0;
  6341.   var paren = 0;
  6342.   var lastFilterIndex = 0;
  6343.   var c, prev, i, expression, filters;
  6344.  
  6345.   for (i = 0; i < exp.length; i++) {
  6346.     prev = c;
  6347.     c = exp.charCodeAt(i);
  6348.     if (inSingle) {
  6349.       if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
  6350.     } else if (inDouble) {
  6351.       if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
  6352.     } else if (inTemplateString) {
  6353.       if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
  6354.     } else if (inRegex) {
  6355.       if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
  6356.     } else if (
  6357.       c === 0x7C && // pipe
  6358.       exp.charCodeAt(i + 1) !== 0x7C &&
  6359.       exp.charCodeAt(i - 1) !== 0x7C &&
  6360.       !curly && !square && !paren
  6361.     ) {
  6362.       if (expression === undefined) {
  6363.         // first filter, end of expression
  6364.         lastFilterIndex = i + 1;
  6365.         expression = exp.slice(0, i).trim();
  6366.       } else {
  6367.         pushFilter();
  6368.       }
  6369.     } else {
  6370.       switch (c) {
  6371.         case 0x22: inDouble = true; break         // "
  6372.         case 0x27: inSingle = true; break         // '
  6373.         case 0x60: inTemplateString = true; break // `
  6374.         case 0x28: paren++; break                 // (
  6375.         case 0x29: paren--; break                 // )
  6376.         case 0x5B: square++; break                // [
  6377.         case 0x5D: square--; break                // ]
  6378.         case 0x7B: curly++; break                 // {
  6379.         case 0x7D: curly--; break                 // }
  6380.       }
  6381.       if (c === 0x2f) { // /
  6382.         var j = i - 1;
  6383.         var p = (void 0);
  6384.         // find first non-whitespace prev char
  6385.         for (; j >= 0; j--) {
  6386.           p = exp.charAt(j);
  6387.           if (p !== ' ') { break }
  6388.         }
  6389.         if (!p || !validDivisionCharRE.test(p)) {
  6390.           inRegex = true;
  6391.         }
  6392.       }
  6393.     }
  6394.   }
  6395.  
  6396.   if (expression === undefined) {
  6397.     expression = exp.slice(0, i).trim();
  6398.   } else if (lastFilterIndex !== 0) {
  6399.     pushFilter();
  6400.   }
  6401.  
  6402.   function pushFilter () {
  6403.     (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
  6404.     lastFilterIndex = i + 1;
  6405.   }
  6406.  
  6407.   if (filters) {
  6408.     for (i = 0; i < filters.length; i++) {
  6409.       expression = wrapFilter(expression, filters[i]);
  6410.     }
  6411.   }
  6412.  
  6413.   return expression
  6414. }
  6415.  
  6416. function wrapFilter (exp, filter) {
  6417.   var i = filter.indexOf('(');
  6418.   if (i < 0) {
  6419.     // _f: resolveFilter
  6420.     return ("_f(\"" + filter + "\")(" + exp + ")")
  6421.   } else {
  6422.     var name = filter.slice(0, i);
  6423.     var args = filter.slice(i + 1);
  6424.     return ("_f(\"" + name + "\")(" + exp + "," + args)
  6425.   }
  6426. }
  6427.  
  6428. /*  */
  6429.  
  6430. function baseWarn (msg) {
  6431.   console.error(("[Vue compiler]: " + msg));
  6432. }
  6433.  
  6434. function pluckModuleFunction (
  6435.   modules,
  6436.   key
  6437. ) {
  6438.   return modules
  6439.     ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
  6440.     : []
  6441. }
  6442.  
  6443. function addProp (el, name, value) {
  6444.   (el.props || (el.props = [])).push({ name: name, value: value });
  6445.   el.plain = false;
  6446. }
  6447.  
  6448. function addAttr (el, name, value) {
  6449.   (el.attrs || (el.attrs = [])).push({ name: name, value: value });
  6450.   el.plain = false;
  6451. }
  6452.  
  6453. // add a raw attr (use this in preTransforms)
  6454. function addRawAttr (el, name, value) {
  6455.   el.attrsMap[name] = value;
  6456.   el.attrsList.push({ name: name, value: value });
  6457. }
  6458.  
  6459. function addDirective (
  6460.   el,
  6461.   name,
  6462.   rawName,
  6463.   value,
  6464.   arg,
  6465.   modifiers
  6466. ) {
  6467.   (el.directives || (el.directives = [])).push({ name: name, rawName: rawName, value: value, arg: arg, modifiers: modifiers });
  6468.   el.plain = false;
  6469. }
  6470.  
  6471. function addHandler (
  6472.   el,
  6473.   name,
  6474.   value,
  6475.   modifiers,
  6476.   important,
  6477.   warn
  6478. ) {
  6479.   modifiers = modifiers || emptyObject;
  6480.   // warn prevent and passive modifier
  6481.   /* istanbul ignore if */
  6482.   if (
  6483.     "development" !== 'production' && warn &&
  6484.     modifiers.prevent && modifiers.passive
  6485.   ) {
  6486.     warn(
  6487.       'passive and prevent can\'t be used together. ' +
  6488.       'Passive handler can\'t prevent default event.'
  6489.     );
  6490.   }
  6491.  
  6492.   // check capture modifier
  6493.   if (modifiers.capture) {
  6494.     delete modifiers.capture;
  6495.     name = '!' + name; // mark the event as captured
  6496.   }
  6497.   if (modifiers.once) {
  6498.     delete modifiers.once;
  6499.     name = '~' + name; // mark the event as once
  6500.   }
  6501.   /* istanbul ignore if */
  6502.   if (modifiers.passive) {
  6503.     delete modifiers.passive;
  6504.     name = '&' + name; // mark the event as passive
  6505.   }
  6506.  
  6507.   // normalize click.right and click.middle since they don't actually fire
  6508.   // this is technically browser-specific, but at least for now browsers are
  6509.   // the only target envs that have right/middle clicks.
  6510.   if (name === 'click') {
  6511.     if (modifiers.right) {
  6512.       name = 'contextmenu';
  6513.       delete modifiers.right;
  6514.     } else if (modifiers.middle) {
  6515.       name = 'mouseup';
  6516.     }
  6517.   }
  6518.  
  6519.   var events;
  6520.   if (modifiers.native) {
  6521.     delete modifiers.native;
  6522.     events = el.nativeEvents || (el.nativeEvents = {});
  6523.   } else {
  6524.     events = el.events || (el.events = {});
  6525.   }
  6526.  
  6527.   var newHandler = { value: value };
  6528.   if (modifiers !== emptyObject) {
  6529.     newHandler.modifiers = modifiers;
  6530.   }
  6531.  
  6532.   var handlers = events[name];
  6533.   /* istanbul ignore if */
  6534.   if (Array.isArray(handlers)) {
  6535.     important ? handlers.unshift(newHandler) : handlers.push(newHandler);
  6536.   } else if (handlers) {
  6537.     events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
  6538.   } else {
  6539.     events[name] = newHandler;
  6540.   }
  6541.  
  6542.   el.plain = false;
  6543. }
  6544.  
  6545. function getBindingAttr (
  6546.   el,
  6547.   name,
  6548.   getStatic
  6549. ) {
  6550.   var dynamicValue =
  6551.     getAndRemoveAttr(el, ':' + name) ||
  6552.     getAndRemoveAttr(el, 'v-bind:' + name);
  6553.   if (dynamicValue != null) {
  6554.     return parseFilters(dynamicValue)
  6555.   } else if (getStatic !== false) {
  6556.     var staticValue = getAndRemoveAttr(el, name);
  6557.     if (staticValue != null) {
  6558.       return JSON.stringify(staticValue)
  6559.     }
  6560.   }
  6561. }
  6562.  
  6563. // note: this only removes the attr from the Array (attrsList) so that it
  6564. // doesn't get processed by processAttrs.
  6565. // By default it does NOT remove it from the map (attrsMap) because the map is
  6566. // needed during codegen.
  6567. function getAndRemoveAttr (
  6568.   el,
  6569.   name,
  6570.   removeFromMap
  6571. ) {
  6572.   var val;
  6573.   if ((val = el.attrsMap[name]) != null) {
  6574.     var list = el.attrsList;
  6575.     for (var i = 0, l = list.length; i < l; i++) {
  6576.       if (list[i].name === name) {
  6577.         list.splice(i, 1);
  6578.         break
  6579.       }
  6580.     }
  6581.   }
  6582.   if (removeFromMap) {
  6583.     delete el.attrsMap[name];
  6584.   }
  6585.   return val
  6586. }
  6587.  
  6588. /*  */
  6589.  
  6590. /**
  6591.  * Cross-platform code generation for component v-model
  6592.  */
  6593. function genComponentModel (
  6594.   el,
  6595.   value,
  6596.   modifiers
  6597. ) {
  6598.   var ref = modifiers || {};
  6599.   var number = ref.number;
  6600.   var trim = ref.trim;
  6601.  
  6602.   var baseValueExpression = '$$v';
  6603.   var valueExpression = baseValueExpression;
  6604.   if (trim) {
  6605.     valueExpression =
  6606.       "(typeof " + baseValueExpression + " === 'string'" +
  6607.         "? " + baseValueExpression + ".trim()" +
  6608.         ": " + baseValueExpression + ")";
  6609.   }
  6610.   if (number) {
  6611.     valueExpression = "_n(" + valueExpression + ")";
  6612.   }
  6613.   var assignment = genAssignmentCode(value, valueExpression);
  6614.  
  6615.   el.model = {
  6616.     value: ("(" + value + ")"),
  6617.     expression: ("\"" + value + "\""),
  6618.     callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
  6619.   };
  6620. }
  6621.  
  6622. /**
  6623.  * Cross-platform codegen helper for generating v-model value assignment code.
  6624.  */
  6625. function genAssignmentCode (
  6626.   value,
  6627.   assignment
  6628. ) {
  6629.   var res = parseModel(value);
  6630.   if (res.key === null) {
  6631.     return (value + "=" + assignment)
  6632.   } else {
  6633.     return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
  6634.   }
  6635. }
  6636.  
  6637. /**
  6638.  * Parse a v-model expression into a base path and a final key segment.
  6639.  * Handles both dot-path and possible square brackets.
  6640.  *
  6641.  * Possible cases:
  6642.  *
  6643.  * - test
  6644.  * - test[key]
  6645.  * - test[test1[key]]
  6646.  * - test["a"][key]
  6647.  * - xxx.test[a[a].test1[key]]
  6648.  * - test.xxx.a["asa"][test1[key]]
  6649.  *
  6650.  */
  6651.  
  6652. var len;
  6653. var str;
  6654. var chr;
  6655. var index$1;
  6656. var expressionPos;
  6657. var expressionEndPos;
  6658.  
  6659.  
  6660.  
  6661. function parseModel (val) {
  6662.   len = val.length;
  6663.  
  6664.   if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
  6665.     index$1 = val.lastIndexOf('.');
  6666.     if (index$1 > -1) {
  6667.       return {
  6668.         exp: val.slice(0, index$1),
  6669.         key: '"' + val.slice(index$1 + 1) + '"'
  6670.       }
  6671.     } else {
  6672.       return {
  6673.         exp: val,
  6674.         key: null
  6675.       }
  6676.     }
  6677.   }
  6678.  
  6679.   str = val;
  6680.   index$1 = expressionPos = expressionEndPos = 0;
  6681.  
  6682.   while (!eof()) {
  6683.     chr = next();
  6684.     /* istanbul ignore if */
  6685.     if (isStringStart(chr)) {
  6686.       parseString(chr);
  6687.     } else if (chr === 0x5B) {
  6688.       parseBracket(chr);
  6689.     }
  6690.   }
  6691.  
  6692.   return {
  6693.     exp: val.slice(0, expressionPos),
  6694.     key: val.slice(expressionPos + 1, expressionEndPos)
  6695.   }
  6696. }
  6697.  
  6698. function next () {
  6699.   return str.charCodeAt(++index$1)
  6700. }
  6701.  
  6702. function eof () {
  6703.   return index$1 >= len
  6704. }
  6705.  
  6706. function isStringStart (chr) {
  6707.   return chr === 0x22 || chr === 0x27
  6708. }
  6709.  
  6710. function parseBracket (chr) {
  6711.   var inBracket = 1;
  6712.   expressionPos = index$1;
  6713.   while (!eof()) {
  6714.     chr = next();
  6715.     if (isStringStart(chr)) {
  6716.       parseString(chr);
  6717.       continue
  6718.     }
  6719.     if (chr === 0x5B) { inBracket++; }
  6720.     if (chr === 0x5D) { inBracket--; }
  6721.     if (inBracket === 0) {
  6722.       expressionEndPos = index$1;
  6723.       break
  6724.     }
  6725.   }
  6726. }
  6727.  
  6728. function parseString (chr) {
  6729.   var stringQuote = chr;
  6730.   while (!eof()) {
  6731.     chr = next();
  6732.     if (chr === stringQuote) {
  6733.       break
  6734.     }
  6735.   }
  6736. }
  6737.  
  6738. /*  */
  6739.  
  6740. var warn$1;
  6741.  
  6742. // in some cases, the event used has to be determined at runtime
  6743. // so we used some reserved tokens during compile.
  6744. var RANGE_TOKEN = '__r';
  6745. var CHECKBOX_RADIO_TOKEN = '__c';
  6746.  
  6747. function model (
  6748.   el,
  6749.   dir,
  6750.   _warn
  6751. ) {
  6752.   warn$1 = _warn;
  6753.   var value = dir.value;
  6754.   var modifiers = dir.modifiers;
  6755.   var tag = el.tag;
  6756.   var type = el.attrsMap.type;
  6757.  
  6758.   {
  6759.     // inputs with type="file" are read only and setting the input's
  6760.     // value will throw an error.
  6761.     if (tag === 'input' && type === 'file') {
  6762.       warn$1(
  6763.         "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
  6764.         "File inputs are read only. Use a v-on:change listener instead."
  6765.       );
  6766.     }
  6767.   }
  6768.  
  6769.   if (el.component) {
  6770.     genComponentModel(el, value, modifiers);
  6771.     // component v-model doesn't need extra runtime
  6772.     return false
  6773.   } else if (tag === 'select') {
  6774.     genSelect(el, value, modifiers);
  6775.   } else if (tag === 'input' && type === 'checkbox') {
  6776.     genCheckboxModel(el, value, modifiers);
  6777.   } else if (tag === 'input' && type === 'radio') {
  6778.     genRadioModel(el, value, modifiers);
  6779.   } else if (tag === 'input' || tag === 'textarea') {
  6780.     genDefaultModel(el, value, modifiers);
  6781.   } else if (!config.isReservedTag(tag)) {
  6782.     genComponentModel(el, value, modifiers);
  6783.     // component v-model doesn't need extra runtime
  6784.     return false
  6785.   } else {
  6786.     warn$1(
  6787.       "<" + (el.tag) + " v-model=\"" + value + "\">: " +
  6788.       "v-model is not supported on this element type. " +
  6789.       'If you are working with contenteditable, it\'s recommended to ' +
  6790.       'wrap a library dedicated for that purpose inside a custom component.'
  6791.     );
  6792.   }
  6793.  
  6794.   // ensure runtime directive metadata
  6795.   return true
  6796. }
  6797.  
  6798. function genCheckboxModel (
  6799.   el,
  6800.   value,
  6801.   modifiers
  6802. ) {
  6803.   var number = modifiers && modifiers.number;
  6804.   var valueBinding = getBindingAttr(el, 'value') || 'null';
  6805.   var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
  6806.   var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
  6807.   addProp(el, 'checked',
  6808.     "Array.isArray(" + value + ")" +
  6809.     "?_i(" + value + "," + valueBinding + ")>-1" + (
  6810.       trueValueBinding === 'true'
  6811.         ? (":(" + value + ")")
  6812.         : (":_q(" + value + "," + trueValueBinding + ")")
  6813.     )
  6814.   );
  6815.   addHandler(el, 'change',
  6816.     "var $$a=" + value + "," +
  6817.         '$$el=$event.target,' +
  6818.         "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
  6819.     'if(Array.isArray($$a)){' +
  6820.       "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
  6821.           '$$i=_i($$a,$$v);' +
  6822.       "if($$el.checked){$$i<0&&(" + value + "=$$a.concat([$$v]))}" +
  6823.       "else{$$i>-1&&(" + value + "=$$a.slice(0,$$i).concat($$a.slice($$i+1)))}" +
  6824.     "}else{" + (genAssignmentCode(value, '$$c')) + "}",
  6825.     null, true
  6826.   );
  6827. }
  6828.  
  6829. function genRadioModel (
  6830.   el,
  6831.   value,
  6832.   modifiers
  6833. ) {
  6834.   var number = modifiers && modifiers.number;
  6835.   var valueBinding = getBindingAttr(el, 'value') || 'null';
  6836.   valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
  6837.   addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
  6838.   addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
  6839. }
  6840.  
  6841. function genSelect (
  6842.   el,
  6843.   value,
  6844.   modifiers
  6845. ) {
  6846.   var number = modifiers && modifiers.number;
  6847.   var selectedVal = "Array.prototype.filter" +
  6848.     ".call($event.target.options,function(o){return o.selected})" +
  6849.     ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
  6850.     "return " + (number ? '_n(val)' : 'val') + "})";
  6851.  
  6852.   var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
  6853.   var code = "var $$selectedVal = " + selectedVal + ";";
  6854.   code = code + " " + (genAssignmentCode(value, assignment));
  6855.   addHandler(el, 'change', code, null, true);
  6856. }
  6857.  
  6858. function genDefaultModel (
  6859.   el,
  6860.   value,
  6861.   modifiers
  6862. ) {
  6863.   var type = el.attrsMap.type;
  6864.  
  6865.   // warn if v-bind:value conflicts with v-model
  6866.   {
  6867.     var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
  6868.     if (value$1) {
  6869.       var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
  6870.       warn$1(
  6871.         binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
  6872.         'because the latter already expands to a value binding internally'
  6873.       );
  6874.     }
  6875.   }
  6876.  
  6877.   var ref = modifiers || {};
  6878.   var lazy = ref.lazy;
  6879.   var number = ref.number;
  6880.   var trim = ref.trim;
  6881.   var needCompositionGuard = !lazy && type !== 'range';
  6882.   var event = lazy
  6883.     ? 'change'
  6884.     : type === 'range'
  6885.       ? RANGE_TOKEN
  6886.       : 'input';
  6887.  
  6888.   var valueExpression = '$event.target.value';
  6889.   if (trim) {
  6890.     valueExpression = "$event.target.value.trim()";
  6891.   }
  6892.   if (number) {
  6893.     valueExpression = "_n(" + valueExpression + ")";
  6894.   }
  6895.  
  6896.   var code = genAssignmentCode(value, valueExpression);
  6897.   if (needCompositionGuard) {
  6898.     code = "if($event.target.composing)return;" + code;
  6899.   }
  6900.  
  6901.   addProp(el, 'value', ("(" + value + ")"));
  6902.   addHandler(el, event, code, null, true);
  6903.   if (trim || number) {
  6904.     addHandler(el, 'blur', '$forceUpdate()');
  6905.   }
  6906. }
  6907.  
  6908. /*  */
  6909.  
  6910. // normalize v-model event tokens that can only be determined at runtime.
  6911. // it's important to place the event as the first in the array because
  6912. // the whole point is ensuring the v-model callback gets called before
  6913. // user-attached handlers.
  6914. function normalizeEvents (on) {
  6915.   /* istanbul ignore if */
  6916.   if (isDef(on[RANGE_TOKEN])) {
  6917.     // IE input[type=range] only supports `change` event
  6918.     var event = isIE ? 'change' : 'input';
  6919.     on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
  6920.     delete on[RANGE_TOKEN];
  6921.   }
  6922.   // This was originally intended to fix #4521 but no longer necessary
  6923.   // after 2.5. Keeping it for backwards compat with generated code from < 2.4
  6924.   /* istanbul ignore if */
  6925.   if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
  6926.     on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
  6927.     delete on[CHECKBOX_RADIO_TOKEN];
  6928.   }
  6929. }
  6930.  
  6931. var target$1;
  6932.  
  6933. function createOnceHandler (handler, event, capture) {
  6934.   var _target = target$1; // save current target element in closure
  6935.   return function onceHandler () {
  6936.     var res = handler.apply(null, arguments);
  6937.     if (res !== null) {
  6938.       remove$2(event, onceHandler, capture, _target);
  6939.     }
  6940.   }
  6941. }
  6942.  
  6943. function add$1 (
  6944.   event,
  6945.   handler,
  6946.   once$$1,
  6947.   capture,
  6948.   passive
  6949. ) {
  6950.   handler = withMacroTask(handler);
  6951.   if (once$$1) { handler = createOnceHandler(handler, event, capture); }
  6952.   target$1.addEventListener(
  6953.     event,
  6954.     handler,
  6955.     supportsPassive
  6956.       ? { capture: capture, passive: passive }
  6957.       : capture
  6958.   );
  6959. }
  6960.  
  6961. function remove$2 (
  6962.   event,
  6963.   handler,
  6964.   capture,
  6965.   _target
  6966. ) {
  6967.   (_target || target$1).removeEventListener(
  6968.     event,
  6969.     handler._withTask || handler,
  6970.     capture
  6971.   );
  6972. }
  6973.  
  6974. function updateDOMListeners (oldVnode, vnode) {
  6975.   if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
  6976.     return
  6977.   }
  6978.   var on = vnode.data.on || {};
  6979.   var oldOn = oldVnode.data.on || {};
  6980.   target$1 = vnode.elm;
  6981.   normalizeEvents(on);
  6982.   updateListeners(on, oldOn, add$1, remove$2, vnode.context);
  6983.   target$1 = undefined;
  6984. }
  6985.  
  6986. var events = {
  6987.   create: updateDOMListeners,
  6988.   update: updateDOMListeners
  6989. };
  6990.  
  6991. /*  */
  6992.  
  6993. function updateDOMProps (oldVnode, vnode) {
  6994.   if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
  6995.     return
  6996.   }
  6997.   var key, cur;
  6998.   var elm = vnode.elm;
  6999.   var oldProps = oldVnode.data.domProps || {};
  7000.   var props = vnode.data.domProps || {};
  7001.   // clone observed objects, as the user probably wants to mutate it
  7002.   if (isDef(props.__ob__)) {
  7003.     props = vnode.data.domProps = extend({}, props);
  7004.   }
  7005.  
  7006.   for (key in oldProps) {
  7007.     if (isUndef(props[key])) {
  7008.       elm[key] = '';
  7009.     }
  7010.   }
  7011.   for (key in props) {
  7012.     cur = props[key];
  7013.     // ignore children if the node has textContent or innerHTML,
  7014.     // as these will throw away existing DOM nodes and cause removal errors
  7015.     // on subsequent patches (#3360)
  7016.     if (key === 'textContent' || key === 'innerHTML') {
  7017.       if (vnode.children) { vnode.children.length = 0; }
  7018.       if (cur === oldProps[key]) { continue }
  7019.       // #6601 work around Chrome version <= 55 bug where single textNode
  7020.       // replaced by innerHTML/textContent retains its parentNode property
  7021.       if (elm.childNodes.length === 1) {
  7022.         elm.removeChild(elm.childNodes[0]);
  7023.       }
  7024.     }
  7025.  
  7026.     if (key === 'value') {
  7027.       // store value as _value as well since
  7028.       // non-string values will be stringified
  7029.       elm._value = cur;
  7030.       // avoid resetting cursor position when value is the same
  7031.       var strCur = isUndef(cur) ? '' : String(cur);
  7032.       if (shouldUpdateValue(elm, strCur)) {
  7033.         elm.value = strCur;
  7034.       }
  7035.     } else {
  7036.       elm[key] = cur;
  7037.     }
  7038.   }
  7039. }
  7040.  
  7041. // check platforms/web/util/attrs.js acceptValue
  7042.  
  7043.  
  7044. function shouldUpdateValue (elm, checkVal) {
  7045.   return (!elm.composing && (
  7046.     elm.tagName === 'OPTION' ||
  7047.     isNotInFocusAndDirty(elm, checkVal) ||
  7048.     isDirtyWithModifiers(elm, checkVal)
  7049.   ))
  7050. }
  7051.  
  7052. function isNotInFocusAndDirty (elm, checkVal) {
  7053.   // return true when textbox (.number and .trim) loses focus and its value is
  7054.   // not equal to the updated value
  7055.   var notInFocus = true;
  7056.   // #6157
  7057.   // work around IE bug when accessing document.activeElement in an iframe
  7058.   try { notInFocus = document.activeElement !== elm; } catch (e) {}
  7059.   return notInFocus && elm.value !== checkVal
  7060. }
  7061.  
  7062. function isDirtyWithModifiers (elm, newVal) {
  7063.   var value = elm.value;
  7064.   var modifiers = elm._vModifiers; // injected by v-model runtime
  7065.   if (isDef(modifiers)) {
  7066.     if (modifiers.lazy) {
  7067.       // inputs with lazy should only be updated when not in focus
  7068.       return false
  7069.     }
  7070.     if (modifiers.number) {
  7071.       return toNumber(value) !== toNumber(newVal)
  7072.     }
  7073.     if (modifiers.trim) {
  7074.       return value.trim() !== newVal.trim()
  7075.     }
  7076.   }
  7077.   return value !== newVal
  7078. }
  7079.  
  7080. var domProps = {
  7081.   create: updateDOMProps,
  7082.   update: updateDOMProps
  7083. };
  7084.  
  7085. /*  */
  7086.  
  7087. var parseStyleText = cached(function (cssText) {
  7088.   var res = {};
  7089.   var listDelimiter = /;(?![^(]*\))/g;
  7090.   var propertyDelimiter = /:(.+)/;
  7091.   cssText.split(listDelimiter).forEach(function (item) {
  7092.     if (item) {
  7093.       var tmp = item.split(propertyDelimiter);
  7094.       tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
  7095.     }
  7096.   });
  7097.   return res
  7098. });
  7099.  
  7100. // merge static and dynamic style data on the same vnode
  7101. function normalizeStyleData (data) {
  7102.   var style = normalizeStyleBinding(data.style);
  7103.   // static style is pre-processed into an object during compilation
  7104.   // and is always a fresh object, so it's safe to merge into it
  7105.   return data.staticStyle
  7106.     ? extend(data.staticStyle, style)
  7107.     : style
  7108. }
  7109.  
  7110. // normalize possible array / string values into Object
  7111. function normalizeStyleBinding (bindingStyle) {
  7112.   if (Array.isArray(bindingStyle)) {
  7113.     return toObject(bindingStyle)
  7114.   }
  7115.   if (typeof bindingStyle === 'string') {
  7116.     return parseStyleText(bindingStyle)
  7117.   }
  7118.   return bindingStyle
  7119. }
  7120.  
  7121. /**
  7122.  * parent component style should be after child's
  7123.  * so that parent component's style could override it
  7124.  */
  7125. function getStyle (vnode, checkChild) {
  7126.   var res = {};
  7127.   var styleData;
  7128.  
  7129.   if (checkChild) {
  7130.     var childNode = vnode;
  7131.     while (childNode.componentInstance) {
  7132.       childNode = childNode.componentInstance._vnode;
  7133.       if (
  7134.         childNode && childNode.data &&
  7135.         (styleData = normalizeStyleData(childNode.data))
  7136.       ) {
  7137.         extend(res, styleData);
  7138.       }
  7139.     }
  7140.   }
  7141.  
  7142.   if ((styleData = normalizeStyleData(vnode.data))) {
  7143.     extend(res, styleData);
  7144.   }
  7145.  
  7146.   var parentNode = vnode;
  7147.   while ((parentNode = parentNode.parent)) {
  7148.     if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
  7149.       extend(res, styleData);
  7150.     }
  7151.   }
  7152.   return res
  7153. }
  7154.  
  7155. /*  */
  7156.  
  7157. var cssVarRE = /^--/;
  7158. var importantRE = /\s*!important$/;
  7159. var setProp = function (el, name, val) {
  7160.   /* istanbul ignore if */
  7161.   if (cssVarRE.test(name)) {
  7162.     el.style.setProperty(name, val);
  7163.   } else if (importantRE.test(val)) {
  7164.     el.style.setProperty(name, val.replace(importantRE, ''), 'important');
  7165.   } else {
  7166.     var normalizedName = normalize(name);
  7167.     if (Array.isArray(val)) {
  7168.       // Support values array created by autoprefixer, e.g.
  7169.       // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
  7170.       // Set them one by one, and the browser will only set those it can recognize
  7171.       for (var i = 0, len = val.length; i < len; i++) {
  7172.         el.style[normalizedName] = val[i];
  7173.       }
  7174.     } else {
  7175.       el.style[normalizedName] = val;
  7176.     }
  7177.   }
  7178. };
  7179.  
  7180. var vendorNames = ['Webkit', 'Moz', 'ms'];
  7181.  
  7182. var emptyStyle;
  7183. var normalize = cached(function (prop) {
  7184.   emptyStyle = emptyStyle || document.createElement('div').style;
  7185.   prop = camelize(prop);
  7186.   if (prop !== 'filter' && (prop in emptyStyle)) {
  7187.     return prop
  7188.   }
  7189.   var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
  7190.   for (var i = 0; i < vendorNames.length; i++) {
  7191.     var name = vendorNames[i] + capName;
  7192.     if (name in emptyStyle) {
  7193.       return name
  7194.     }
  7195.   }
  7196. });
  7197.  
  7198. function updateStyle (oldVnode, vnode) {
  7199.   var data = vnode.data;
  7200.   var oldData = oldVnode.data;
  7201.  
  7202.   if (isUndef(data.staticStyle) && isUndef(data.style) &&
  7203.     isUndef(oldData.staticStyle) && isUndef(oldData.style)
  7204.   ) {
  7205.     return
  7206.   }
  7207.  
  7208.   var cur, name;
  7209.   var el = vnode.elm;
  7210.   var oldStaticStyle = oldData.staticStyle;
  7211.   var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
  7212.  
  7213.   // if static style exists, stylebinding already merged into it when doing normalizeStyleData
  7214.   var oldStyle = oldStaticStyle || oldStyleBinding;
  7215.  
  7216.   var style = normalizeStyleBinding(vnode.data.style) || {};
  7217.  
  7218.   // store normalized style under a different key for next diff
  7219.   // make sure to clone it if it's reactive, since the user likely wants
  7220.   // to mutate it.
  7221.   vnode.data.normalizedStyle = isDef(style.__ob__)
  7222.     ? extend({}, style)
  7223.     : style;
  7224.  
  7225.   var newStyle = getStyle(vnode, true);
  7226.  
  7227.   for (name in oldStyle) {
  7228.     if (isUndef(newStyle[name])) {
  7229.       setProp(el, name, '');
  7230.     }
  7231.   }
  7232.   for (name in newStyle) {
  7233.     cur = newStyle[name];
  7234.     if (cur !== oldStyle[name]) {
  7235.       // ie9 setting to null has no effect, must use empty string
  7236.       setProp(el, name, cur == null ? '' : cur);
  7237.     }
  7238.   }
  7239. }
  7240.  
  7241. var style = {
  7242.   create: updateStyle,
  7243.   update: updateStyle
  7244. };
  7245.  
  7246. /*  */
  7247.  
  7248. /**
  7249.  * Add class with compatibility for SVG since classList is not supported on
  7250.  * SVG elements in IE
  7251.  */
  7252. function addClass (el, cls) {
  7253.   /* istanbul ignore if */
  7254.   if (!cls || !(cls = cls.trim())) {
  7255.     return
  7256.   }
  7257.  
  7258.   /* istanbul ignore else */
  7259.   if (el.classList) {
  7260.     if (cls.indexOf(' ') > -1) {
  7261.       cls.split(/\s+/).forEach(function (c) { return el.classList.add(c); });
  7262.     } else {
  7263.       el.classList.add(cls);
  7264.     }
  7265.   } else {
  7266.     var cur = " " + (el.getAttribute('class') || '') + " ";
  7267.     if (cur.indexOf(' ' + cls + ' ') < 0) {
  7268.       el.setAttribute('class', (cur + cls).trim());
  7269.     }
  7270.   }
  7271. }
  7272.  
  7273. /**
  7274.  * Remove class with compatibility for SVG since classList is not supported on
  7275.  * SVG elements in IE
  7276.  */
  7277. function removeClass (el, cls) {
  7278.   /* istanbul ignore if */
  7279.   if (!cls || !(cls = cls.trim())) {
  7280.     return
  7281.   }
  7282.  
  7283.   /* istanbul ignore else */
  7284.   if (el.classList) {
  7285.     if (cls.indexOf(' ') > -1) {
  7286.       cls.split(/\s+/).forEach(function (c) { return el.classList.remove(c); });
  7287.     } else {
  7288.       el.classList.remove(cls);
  7289.     }
  7290.     if (!el.classList.length) {
  7291.       el.removeAttribute('class');
  7292.     }
  7293.   } else {
  7294.     var cur = " " + (el.getAttribute('class') || '') + " ";
  7295.     var tar = ' ' + cls + ' ';
  7296.     while (cur.indexOf(tar) >= 0) {
  7297.       cur = cur.replace(tar, ' ');
  7298.     }
  7299.     cur = cur.trim();
  7300.     if (cur) {
  7301.       el.setAttribute('class', cur);
  7302.     } else {
  7303.       el.removeAttribute('class');
  7304.     }
  7305.   }
  7306. }
  7307.  
  7308. /*  */
  7309.  
  7310. function resolveTransition (def) {
  7311.   if (!def) {
  7312.     return
  7313.   }
  7314.   /* istanbul ignore else */
  7315.   if (typeof def === 'object') {
  7316.     var res = {};
  7317.     if (def.css !== false) {
  7318.       extend(res, autoCssTransition(def.name || 'v'));
  7319.     }
  7320.     extend(res, def);
  7321.     return res
  7322.   } else if (typeof def === 'string') {
  7323.     return autoCssTransition(def)
  7324.   }
  7325. }
  7326.  
  7327. var autoCssTransition = cached(function (name) {
  7328.   return {
  7329.     enterClass: (name + "-enter"),
  7330.     enterToClass: (name + "-enter-to"),
  7331.     enterActiveClass: (name + "-enter-active"),
  7332.     leaveClass: (name + "-leave"),
  7333.     leaveToClass: (name + "-leave-to"),
  7334.     leaveActiveClass: (name + "-leave-active")
  7335.   }
  7336. });
  7337.  
  7338. var hasTransition = inBrowser && !isIE9;
  7339. var TRANSITION = 'transition';
  7340. var ANIMATION = 'animation';
  7341.  
  7342. // Transition property/event sniffing
  7343. var transitionProp = 'transition';
  7344. var transitionEndEvent = 'transitionend';
  7345. var animationProp = 'animation';
  7346. var animationEndEvent = 'animationend';
  7347. if (hasTransition) {
  7348.   /* istanbul ignore if */
  7349.   if (window.ontransitionend === undefined &&
  7350.     window.onwebkittransitionend !== undefined
  7351.   ) {
  7352.     transitionProp = 'WebkitTransition';
  7353.     transitionEndEvent = 'webkitTransitionEnd';
  7354.   }
  7355.   if (window.onanimationend === undefined &&
  7356.     window.onwebkitanimationend !== undefined
  7357.   ) {
  7358.     animationProp = 'WebkitAnimation';
  7359.     animationEndEvent = 'webkitAnimationEnd';
  7360.   }
  7361. }
  7362.  
  7363. // binding to window is necessary to make hot reload work in IE in strict mode
  7364. var raf = inBrowser
  7365.   ? window.requestAnimationFrame
  7366.     ? window.requestAnimationFrame.bind(window)
  7367.     : setTimeout
  7368.   : /* istanbul ignore next */ function (fn) { return fn(); };
  7369.  
  7370. function nextFrame (fn) {
  7371.   raf(function () {
  7372.     raf(fn);
  7373.   });
  7374. }
  7375.  
  7376. function addTransitionClass (el, cls) {
  7377.   var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
  7378.   if (transitionClasses.indexOf(cls) < 0) {
  7379.     transitionClasses.push(cls);
  7380.     addClass(el, cls);
  7381.   }
  7382. }
  7383.  
  7384. function removeTransitionClass (el, cls) {
  7385.   if (el._transitionClasses) {
  7386.     remove(el._transitionClasses, cls);
  7387.   }
  7388.   removeClass(el, cls);
  7389. }
  7390.  
  7391. function whenTransitionEnds (
  7392.   el,
  7393.   expectedType,
  7394.   cb
  7395. ) {
  7396.   var ref = getTransitionInfo(el, expectedType);
  7397.   var type = ref.type;
  7398.   var timeout = ref.timeout;
  7399.   var propCount = ref.propCount;
  7400.   if (!type) { return cb() }
  7401.   var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
  7402.   var ended = 0;
  7403.   var end = function () {
  7404.     el.removeEventListener(event, onEnd);
  7405.     cb();
  7406.   };
  7407.   var onEnd = function (e) {
  7408.     if (e.target === el) {
  7409.       if (++ended >= propCount) {
  7410.         end();
  7411.       }
  7412.     }
  7413.   };
  7414.   setTimeout(function () {
  7415.     if (ended < propCount) {
  7416.       end();
  7417.     }
  7418.   }, timeout + 1);
  7419.   el.addEventListener(event, onEnd);
  7420. }
  7421.  
  7422. var transformRE = /\b(transform|all)(,|$)/;
  7423.  
  7424. function getTransitionInfo (el, expectedType) {
  7425.   var styles = window.getComputedStyle(el);
  7426.   var transitionDelays = styles[transitionProp + 'Delay'].split(', ');
  7427.   var transitionDurations = styles[transitionProp + 'Duration'].split(', ');
  7428.   var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
  7429.   var animationDelays = styles[animationProp + 'Delay'].split(', ');
  7430.   var animationDurations = styles[animationProp + 'Duration'].split(', ');
  7431.   var animationTimeout = getTimeout(animationDelays, animationDurations);
  7432.  
  7433.   var type;
  7434.   var timeout = 0;
  7435.   var propCount = 0;
  7436.   /* istanbul ignore if */
  7437.   if (expectedType === TRANSITION) {
  7438.     if (transitionTimeout > 0) {
  7439.       type = TRANSITION;
  7440.       timeout = transitionTimeout;
  7441.       propCount = transitionDurations.length;
  7442.     }
  7443.   } else if (expectedType === ANIMATION) {
  7444.     if (animationTimeout > 0) {
  7445.       type = ANIMATION;
  7446.       timeout = animationTimeout;
  7447.       propCount = animationDurations.length;
  7448.     }
  7449.   } else {
  7450.     timeout = Math.max(transitionTimeout, animationTimeout);
  7451.     type = timeout > 0
  7452.       ? transitionTimeout > animationTimeout
  7453.         ? TRANSITION
  7454.         : ANIMATION
  7455.       : null;
  7456.     propCount = type
  7457.       ? type === TRANSITION
  7458.         ? transitionDurations.length
  7459.         : animationDurations.length
  7460.       : 0;
  7461.   }
  7462.   var hasTransform =
  7463.     type === TRANSITION &&
  7464.     transformRE.test(styles[transitionProp + 'Property']);
  7465.   return {
  7466.     type: type,
  7467.     timeout: timeout,
  7468.     propCount: propCount,
  7469.     hasTransform: hasTransform
  7470.   }
  7471. }
  7472.  
  7473. function getTimeout (delays, durations) {
  7474.   /* istanbul ignore next */
  7475.   while (delays.length < durations.length) {
  7476.     delays = delays.concat(delays);
  7477.   }
  7478.  
  7479.   return Math.max.apply(null, durations.map(function (d, i) {
  7480.     return toMs(d) + toMs(delays[i])
  7481.   }))
  7482. }
  7483.  
  7484. function toMs (s) {
  7485.   return Number(s.slice(0, -1)) * 1000
  7486. }
  7487.  
  7488. /*  */
  7489.  
  7490. function enter (vnode, toggleDisplay) {
  7491.   var el = vnode.elm;
  7492.  
  7493.   // call leave callback now
  7494.   if (isDef(el._leaveCb)) {
  7495.     el._leaveCb.cancelled = true;
  7496.     el._leaveCb();
  7497.   }
  7498.  
  7499.   var data = resolveTransition(vnode.data.transition);
  7500.   if (isUndef(data)) {
  7501.     return
  7502.   }
  7503.  
  7504.   /* istanbul ignore if */
  7505.   if (isDef(el._enterCb) || el.nodeType !== 1) {
  7506.     return
  7507.   }
  7508.  
  7509.   var css = data.css;
  7510.   var type = data.type;
  7511.   var enterClass = data.enterClass;
  7512.   var enterToClass = data.enterToClass;
  7513.   var enterActiveClass = data.enterActiveClass;
  7514.   var appearClass = data.appearClass;
  7515.   var appearToClass = data.appearToClass;
  7516.   var appearActiveClass = data.appearActiveClass;
  7517.   var beforeEnter = data.beforeEnter;
  7518.   var enter = data.enter;
  7519.   var afterEnter = data.afterEnter;
  7520.   var enterCancelled = data.enterCancelled;
  7521.   var beforeAppear = data.beforeAppear;
  7522.   var appear = data.appear;
  7523.   var afterAppear = data.afterAppear;
  7524.   var appearCancelled = data.appearCancelled;
  7525.   var duration = data.duration;
  7526.  
  7527.   // activeInstance will always be the <transition> component managing this
  7528.   // transition. One edge case to check is when the <transition> is placed
  7529.   // as the root node of a child component. In that case we need to check
  7530.   // <transition>'s parent for appear check.
  7531.   var context = activeInstance;
  7532.   var transitionNode = activeInstance.$vnode;
  7533.   while (transitionNode && transitionNode.parent) {
  7534.     transitionNode = transitionNode.parent;
  7535.     context = transitionNode.context;
  7536.   }
  7537.  
  7538.   var isAppear = !context._isMounted || !vnode.isRootInsert;
  7539.  
  7540.   if (isAppear && !appear && appear !== '') {
  7541.     return
  7542.   }
  7543.  
  7544.   var startClass = isAppear && appearClass
  7545.     ? appearClass
  7546.     : enterClass;
  7547.   var activeClass = isAppear && appearActiveClass
  7548.     ? appearActiveClass
  7549.     : enterActiveClass;
  7550.   var toClass = isAppear && appearToClass
  7551.     ? appearToClass
  7552.     : enterToClass;
  7553.  
  7554.   var beforeEnterHook = isAppear
  7555.     ? (beforeAppear || beforeEnter)
  7556.     : beforeEnter;
  7557.   var enterHook = isAppear
  7558.     ? (typeof appear === 'function' ? appear : enter)
  7559.     : enter;
  7560.   var afterEnterHook = isAppear
  7561.     ? (afterAppear || afterEnter)
  7562.     : afterEnter;
  7563.   var enterCancelledHook = isAppear
  7564.     ? (appearCancelled || enterCancelled)
  7565.     : enterCancelled;
  7566.  
  7567.   var explicitEnterDuration = toNumber(
  7568.     isObject(duration)
  7569.       ? duration.enter
  7570.       : duration
  7571.   );
  7572.  
  7573.   if ("development" !== 'production' && explicitEnterDuration != null) {
  7574.     checkDuration(explicitEnterDuration, 'enter', vnode);
  7575.   }
  7576.  
  7577.   var expectsCSS = css !== false && !isIE9;
  7578.   var userWantsControl = getHookArgumentsLength(enterHook);
  7579.  
  7580.   var cb = el._enterCb = once(function () {
  7581.     if (expectsCSS) {
  7582.       removeTransitionClass(el, toClass);
  7583.       removeTransitionClass(el, activeClass);
  7584.     }
  7585.     if (cb.cancelled) {
  7586.       if (expectsCSS) {
  7587.         removeTransitionClass(el, startClass);
  7588.       }
  7589.       enterCancelledHook && enterCancelledHook(el);
  7590.     } else {
  7591.       afterEnterHook && afterEnterHook(el);
  7592.     }
  7593.     el._enterCb = null;
  7594.   });
  7595.  
  7596.   if (!vnode.data.show) {
  7597.     // remove pending leave element on enter by injecting an insert hook
  7598.     mergeVNodeHook(vnode, 'insert', function () {
  7599.       var parent = el.parentNode;
  7600.       var pendingNode = parent && parent._pending && parent._pending[vnode.key];
  7601.       if (pendingNode &&
  7602.         pendingNode.tag === vnode.tag &&
  7603.         pendingNode.elm._leaveCb
  7604.       ) {
  7605.         pendingNode.elm._leaveCb();
  7606.       }
  7607.       enterHook && enterHook(el, cb);
  7608.     });
  7609.   }
  7610.  
  7611.   // start enter transition
  7612.   beforeEnterHook && beforeEnterHook(el);
  7613.   if (expectsCSS) {
  7614.     addTransitionClass(el, startClass);
  7615.     addTransitionClass(el, activeClass);
  7616.     nextFrame(function () {
  7617.       addTransitionClass(el, toClass);
  7618.       removeTransitionClass(el, startClass);
  7619.       if (!cb.cancelled && !userWantsControl) {
  7620.         if (isValidDuration(explicitEnterDuration)) {
  7621.           setTimeout(cb, explicitEnterDuration);
  7622.         } else {
  7623.           whenTransitionEnds(el, type, cb);
  7624.         }
  7625.       }
  7626.     });
  7627.   }
  7628.  
  7629.   if (vnode.data.show) {
  7630.     toggleDisplay && toggleDisplay();
  7631.     enterHook && enterHook(el, cb);
  7632.   }
  7633.  
  7634.   if (!expectsCSS && !userWantsControl) {
  7635.     cb();
  7636.   }
  7637. }
  7638.  
  7639. function leave (vnode, rm) {
  7640.   var el = vnode.elm;
  7641.  
  7642.   // call enter callback now
  7643.   if (isDef(el._enterCb)) {
  7644.     el._enterCb.cancelled = true;
  7645.     el._enterCb();
  7646.   }
  7647.  
  7648.   var data = resolveTransition(vnode.data.transition);
  7649.   if (isUndef(data) || el.nodeType !== 1) {
  7650.     return rm()
  7651.   }
  7652.  
  7653.   /* istanbul ignore if */
  7654.   if (isDef(el._leaveCb)) {
  7655.     return
  7656.   }
  7657.  
  7658.   var css = data.css;
  7659.   var type = data.type;
  7660.   var leaveClass = data.leaveClass;
  7661.   var leaveToClass = data.leaveToClass;
  7662.   var leaveActiveClass = data.leaveActiveClass;
  7663.   var beforeLeave = data.beforeLeave;
  7664.   var leave = data.leave;
  7665.   var afterLeave = data.afterLeave;
  7666.   var leaveCancelled = data.leaveCancelled;
  7667.   var delayLeave = data.delayLeave;
  7668.   var duration = data.duration;
  7669.  
  7670.   var expectsCSS = css !== false && !isIE9;
  7671.   var userWantsControl = getHookArgumentsLength(leave);
  7672.  
  7673.   var explicitLeaveDuration = toNumber(
  7674.     isObject(duration)
  7675.       ? duration.leave
  7676.       : duration
  7677.   );
  7678.  
  7679.   if ("development" !== 'production' && isDef(explicitLeaveDuration)) {
  7680.     checkDuration(explicitLeaveDuration, 'leave', vnode);
  7681.   }
  7682.  
  7683.   var cb = el._leaveCb = once(function () {
  7684.     if (el.parentNode && el.parentNode._pending) {
  7685.       el.parentNode._pending[vnode.key] = null;
  7686.     }
  7687.     if (expectsCSS) {
  7688.       removeTransitionClass(el, leaveToClass);
  7689.       removeTransitionClass(el, leaveActiveClass);
  7690.     }
  7691.     if (cb.cancelled) {
  7692.       if (expectsCSS) {
  7693.         removeTransitionClass(el, leaveClass);
  7694.       }
  7695.       leaveCancelled && leaveCancelled(el);
  7696.     } else {
  7697.       rm();
  7698.       afterLeave && afterLeave(el);
  7699.     }
  7700.     el._leaveCb = null;
  7701.   });
  7702.  
  7703.   if (delayLeave) {
  7704.     delayLeave(performLeave);
  7705.   } else {
  7706.     performLeave();
  7707.   }
  7708.  
  7709.   function performLeave () {
  7710.     // the delayed leave may have already been cancelled
  7711.     if (cb.cancelled) {
  7712.       return
  7713.     }
  7714.     // record leaving element
  7715.     if (!vnode.data.show) {
  7716.       (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
  7717.     }
  7718.     beforeLeave && beforeLeave(el);
  7719.     if (expectsCSS) {
  7720.       addTransitionClass(el, leaveClass);
  7721.       addTransitionClass(el, leaveActiveClass);
  7722.       nextFrame(function () {
  7723.         addTransitionClass(el, leaveToClass);
  7724.         removeTransitionClass(el, leaveClass);
  7725.         if (!cb.cancelled && !userWantsControl) {
  7726.           if (isValidDuration(explicitLeaveDuration)) {
  7727.             setTimeout(cb, explicitLeaveDuration);
  7728.           } else {
  7729.             whenTransitionEnds(el, type, cb);
  7730.           }
  7731.         }
  7732.       });
  7733.     }
  7734.     leave && leave(el, cb);
  7735.     if (!expectsCSS && !userWantsControl) {
  7736.       cb();
  7737.     }
  7738.   }
  7739. }
  7740.  
  7741. // only used in dev mode
  7742. function checkDuration (val, name, vnode) {
  7743.   if (typeof val !== 'number') {
  7744.     warn(
  7745.       "<transition> explicit " + name + " duration is not a valid number - " +
  7746.       "got " + (JSON.stringify(val)) + ".",
  7747.       vnode.context
  7748.     );
  7749.   } else if (isNaN(val)) {
  7750.     warn(
  7751.       "<transition> explicit " + name + " duration is NaN - " +
  7752.       'the duration expression might be incorrect.',
  7753.       vnode.context
  7754.     );
  7755.   }
  7756. }
  7757.  
  7758. function isValidDuration (val) {
  7759.   return typeof val === 'number' && !isNaN(val)
  7760. }
  7761.  
  7762. /**
  7763.  * Normalize a transition hook's argument length. The hook may be:
  7764.  * - a merged hook (invoker) with the original in .fns
  7765.  * - a wrapped component method (check ._length)
  7766.  * - a plain function (.length)
  7767.  */
  7768. function getHookArgumentsLength (fn) {
  7769.   if (isUndef(fn)) {
  7770.     return false
  7771.   }
  7772.   var invokerFns = fn.fns;
  7773.   if (isDef(invokerFns)) {
  7774.     // invoker
  7775.     return getHookArgumentsLength(
  7776.       Array.isArray(invokerFns)
  7777.         ? invokerFns[0]
  7778.         : invokerFns
  7779.     )
  7780.   } else {
  7781.     return (fn._length || fn.length) > 1
  7782.   }
  7783. }
  7784.  
  7785. function _enter (_, vnode) {
  7786.   if (vnode.data.show !== true) {
  7787.     enter(vnode);
  7788.   }
  7789. }
  7790.  
  7791. var transition = inBrowser ? {
  7792.   create: _enter,
  7793.   activate: _enter,
  7794.   remove: function remove$$1 (vnode, rm) {
  7795.     /* istanbul ignore else */
  7796.     if (vnode.data.show !== true) {
  7797.       leave(vnode, rm);
  7798.     } else {
  7799.       rm();
  7800.     }
  7801.   }
  7802. } : {};
  7803.  
  7804. var platformModules = [
  7805.   attrs,
  7806.   klass,
  7807.   events,
  7808.   domProps,
  7809.   style,
  7810.   transition
  7811. ];
  7812.  
  7813. /*  */
  7814.  
  7815. // the directive module should be applied last, after all
  7816. // built-in modules have been applied.
  7817. var modules = platformModules.concat(baseModules);
  7818.  
  7819. var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
  7820.  
  7821. /**
  7822.  * Not type checking this file because flow doesn't like attaching
  7823.  * properties to Elements.
  7824.  */
  7825.  
  7826. /* istanbul ignore if */
  7827. if (isIE9) {
  7828.   // http://www.matts411.com/post/internet-explorer-9-oninput/
  7829.   document.addEventListener('selectionchange', function () {
  7830.     var el = document.activeElement;
  7831.     if (el && el.vmodel) {
  7832.       trigger(el, 'input');
  7833.     }
  7834.   });
  7835. }
  7836.  
  7837. var directive = {
  7838.   inserted: function inserted (el, binding, vnode, oldVnode) {
  7839.     if (vnode.tag === 'select') {
  7840.       // #6903
  7841.       if (oldVnode.elm && !oldVnode.elm._vOptions) {
  7842.         mergeVNodeHook(vnode, 'postpatch', function () {
  7843.           directive.componentUpdated(el, binding, vnode);
  7844.         });
  7845.       } else {
  7846.         setSelected(el, binding, vnode.context);
  7847.       }
  7848.       el._vOptions = [].map.call(el.options, getValue);
  7849.     } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
  7850.       el._vModifiers = binding.modifiers;
  7851.       if (!binding.modifiers.lazy) {
  7852.         // Safari < 10.2 & UIWebView doesn't fire compositionend when
  7853.         // switching focus before confirming composition choice
  7854.         // this also fixes the issue where some browsers e.g. iOS Chrome
  7855.         // fires "change" instead of "input" on autocomplete.
  7856.         el.addEventListener('change', onCompositionEnd);
  7857.         if (!isAndroid) {
  7858.           el.addEventListener('compositionstart', onCompositionStart);
  7859.           el.addEventListener('compositionend', onCompositionEnd);
  7860.         }
  7861.         /* istanbul ignore if */
  7862.         if (isIE9) {
  7863.           el.vmodel = true;
  7864.         }
  7865.       }
  7866.     }
  7867.   },
  7868.  
  7869.   componentUpdated: function componentUpdated (el, binding, vnode) {
  7870.     if (vnode.tag === 'select') {
  7871.       setSelected(el, binding, vnode.context);
  7872.       // in case the options rendered by v-for have changed,
  7873.       // it's possible that the value is out-of-sync with the rendered options.
  7874.       // detect such cases and filter out values that no longer has a matching
  7875.       // option in the DOM.
  7876.       var prevOptions = el._vOptions;
  7877.       var curOptions = el._vOptions = [].map.call(el.options, getValue);
  7878.       if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
  7879.         // trigger change event if
  7880.         // no matching option found for at least one value
  7881.         var needReset = el.multiple
  7882.           ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
  7883.           : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
  7884.         if (needReset) {
  7885.           trigger(el, 'change');
  7886.         }
  7887.       }
  7888.     }
  7889.   }
  7890. };
  7891.  
  7892. function setSelected (el, binding, vm) {
  7893.   actuallySetSelected(el, binding, vm);
  7894.   /* istanbul ignore if */
  7895.   if (isIE || isEdge) {
  7896.     setTimeout(function () {
  7897.       actuallySetSelected(el, binding, vm);
  7898.     }, 0);
  7899.   }
  7900. }
  7901.  
  7902. function actuallySetSelected (el, binding, vm) {
  7903.   var value = binding.value;
  7904.   var isMultiple = el.multiple;
  7905.   if (isMultiple && !Array.isArray(value)) {
  7906.     "development" !== 'production' && warn(
  7907.       "<select multiple v-model=\"" + (binding.expression) + "\"> " +
  7908.       "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
  7909.       vm
  7910.     );
  7911.     return
  7912.   }
  7913.   var selected, option;
  7914.   for (var i = 0, l = el.options.length; i < l; i++) {
  7915.     option = el.options[i];
  7916.     if (isMultiple) {
  7917.       selected = looseIndexOf(value, getValue(option)) > -1;
  7918.       if (option.selected !== selected) {
  7919.         option.selected = selected;
  7920.       }
  7921.     } else {
  7922.       if (looseEqual(getValue(option), value)) {
  7923.         if (el.selectedIndex !== i) {
  7924.           el.selectedIndex = i;
  7925.         }
  7926.         return
  7927.       }
  7928.     }
  7929.   }
  7930.   if (!isMultiple) {
  7931.     el.selectedIndex = -1;
  7932.   }
  7933. }
  7934.  
  7935. function hasNoMatchingOption (value, options) {
  7936.   return options.every(function (o) { return !looseEqual(o, value); })
  7937. }
  7938.  
  7939. function getValue (option) {
  7940.   return '_value' in option
  7941.     ? option._value
  7942.     : option.value
  7943. }
  7944.  
  7945. function onCompositionStart (e) {
  7946.   e.target.composing = true;
  7947. }
  7948.  
  7949. function onCompositionEnd (e) {
  7950.   // prevent triggering an input event for no reason
  7951.   if (!e.target.composing) { return }
  7952.   e.target.composing = false;
  7953.   trigger(e.target, 'input');
  7954. }
  7955.  
  7956. function trigger (el, type) {
  7957.   var e = document.createEvent('HTMLEvents');
  7958.   e.initEvent(type, true, true);
  7959.   el.dispatchEvent(e);
  7960. }
  7961.  
  7962. /*  */
  7963.  
  7964. // recursively search for possible transition defined inside the component root
  7965. function locateNode (vnode) {
  7966.   return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
  7967.     ? locateNode(vnode.componentInstance._vnode)
  7968.     : vnode
  7969. }
  7970.  
  7971. var show = {
  7972.   bind: function bind (el, ref, vnode) {
  7973.     var value = ref.value;
  7974.  
  7975.     vnode = locateNode(vnode);
  7976.     var transition$$1 = vnode.data && vnode.data.transition;
  7977.     var originalDisplay = el.__vOriginalDisplay =
  7978.       el.style.display === 'none' ? '' : el.style.display;
  7979.     if (value && transition$$1) {
  7980.       vnode.data.show = true;
  7981.       enter(vnode, function () {
  7982.         el.style.display = originalDisplay;
  7983.       });
  7984.     } else {
  7985.       el.style.display = value ? originalDisplay : 'none';
  7986.     }
  7987.   },
  7988.  
  7989.   update: function update (el, ref, vnode) {
  7990.     var value = ref.value;
  7991.     var oldValue = ref.oldValue;
  7992.  
  7993.     /* istanbul ignore if */
  7994.     if (value === oldValue) { return }
  7995.     vnode = locateNode(vnode);
  7996.     var transition$$1 = vnode.data && vnode.data.transition;
  7997.     if (transition$$1) {
  7998.       vnode.data.show = true;
  7999.       if (value) {
  8000.         enter(vnode, function () {
  8001.           el.style.display = el.__vOriginalDisplay;
  8002.         });
  8003.       } else {
  8004.         leave(vnode, function () {
  8005.           el.style.display = 'none';
  8006.         });
  8007.       }
  8008.     } else {
  8009.       el.style.display = value ? el.__vOriginalDisplay : 'none';
  8010.     }
  8011.   },
  8012.  
  8013.   unbind: function unbind (
  8014.     el,
  8015.     binding,
  8016.     vnode,
  8017.     oldVnode,
  8018.     isDestroy
  8019.   ) {
  8020.     if (!isDestroy) {
  8021.       el.style.display = el.__vOriginalDisplay;
  8022.     }
  8023.   }
  8024. };
  8025.  
  8026. var platformDirectives = {
  8027.   model: directive,
  8028.   show: show
  8029. };
  8030.  
  8031. /*  */
  8032.  
  8033. // Provides transition support for a single element/component.
  8034. // supports transition mode (out-in / in-out)
  8035.  
  8036. var transitionProps = {
  8037.   name: String,
  8038.   appear: Boolean,
  8039.   css: Boolean,
  8040.   mode: String,
  8041.   type: String,
  8042.   enterClass: String,
  8043.   leaveClass: String,
  8044.   enterToClass: String,
  8045.   leaveToClass: String,
  8046.   enterActiveClass: String,
  8047.   leaveActiveClass: String,
  8048.   appearClass: String,
  8049.   appearActiveClass: String,
  8050.   appearToClass: String,
  8051.   duration: [Number, String, Object]
  8052. };
  8053.  
  8054. // in case the child is also an abstract component, e.g. <keep-alive>
  8055. // we want to recursively retrieve the real component to be rendered
  8056. function getRealChild (vnode) {
  8057.   var compOptions = vnode && vnode.componentOptions;
  8058.   if (compOptions && compOptions.Ctor.options.abstract) {
  8059.     return getRealChild(getFirstComponentChild(compOptions.children))
  8060.   } else {
  8061.     return vnode
  8062.   }
  8063. }
  8064.  
  8065. function extractTransitionData (comp) {
  8066.   var data = {};
  8067.   var options = comp.$options;
  8068.   // props
  8069.   for (var key in options.propsData) {
  8070.     data[key] = comp[key];
  8071.   }
  8072.   // events.
  8073.   // extract listeners and pass them directly to the transition methods
  8074.   var listeners = options._parentListeners;
  8075.   for (var key$1 in listeners) {
  8076.     data[camelize(key$1)] = listeners[key$1];
  8077.   }
  8078.   return data
  8079. }
  8080.  
  8081. function placeholder (h, rawChild) {
  8082.   if (/\d-keep-alive$/.test(rawChild.tag)) {
  8083.     return h('keep-alive', {
  8084.       props: rawChild.componentOptions.propsData
  8085.     })
  8086.   }
  8087. }
  8088.  
  8089. function hasParentTransition (vnode) {
  8090.   while ((vnode = vnode.parent)) {
  8091.     if (vnode.data.transition) {
  8092.       return true
  8093.     }
  8094.   }
  8095. }
  8096.  
  8097. function isSameChild (child, oldChild) {
  8098.   return oldChild.key === child.key && oldChild.tag === child.tag
  8099. }
  8100.  
  8101. var Transition = {
  8102.   name: 'transition',
  8103.   props: transitionProps,
  8104.   abstract: true,
  8105.  
  8106.   render: function render (h) {
  8107.     var this$1 = this;
  8108.  
  8109.     var children = this.$slots.default;
  8110.     if (!children) {
  8111.       return
  8112.     }
  8113.  
  8114.     // filter out text nodes (possible whitespaces)
  8115.     children = children.filter(function (c) { return c.tag || isAsyncPlaceholder(c); });
  8116.     /* istanbul ignore if */
  8117.     if (!children.length) {
  8118.       return
  8119.     }
  8120.  
  8121.     // warn multiple elements
  8122.     if ("development" !== 'production' && children.length > 1) {
  8123.       warn(
  8124.         '<transition> can only be used on a single element. Use ' +
  8125.         '<transition-group> for lists.',
  8126.         this.$parent
  8127.       );
  8128.     }
  8129.  
  8130.     var mode = this.mode;
  8131.  
  8132.     // warn invalid mode
  8133.     if ("development" !== 'production' &&
  8134.       mode && mode !== 'in-out' && mode !== 'out-in'
  8135.     ) {
  8136.       warn(
  8137.         'invalid <transition> mode: ' + mode,
  8138.         this.$parent
  8139.       );
  8140.     }
  8141.  
  8142.     var rawChild = children[0];
  8143.  
  8144.     // if this is a component root node and the component's
  8145.     // parent container node also has transition, skip.
  8146.     if (hasParentTransition(this.$vnode)) {
  8147.       return rawChild
  8148.     }
  8149.  
  8150.     // apply transition data to child
  8151.     // use getRealChild() to ignore abstract components e.g. keep-alive
  8152.     var child = getRealChild(rawChild);
  8153.     /* istanbul ignore if */
  8154.     if (!child) {
  8155.       return rawChild
  8156.     }
  8157.  
  8158.     if (this._leaving) {
  8159.       return placeholder(h, rawChild)
  8160.     }
  8161.  
  8162.     // ensure a key that is unique to the vnode type and to this transition
  8163.     // component instance. This key will be used to remove pending leaving nodes
  8164.     // during entering.
  8165.     var id = "__transition-" + (this._uid) + "-";
  8166.     child.key = child.key == null
  8167.       ? child.isComment
  8168.         ? id + 'comment'
  8169.         : id + child.tag
  8170.       : isPrimitive(child.key)
  8171.         ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
  8172.         : child.key;
  8173.  
  8174.     var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
  8175.     var oldRawChild = this._vnode;
  8176.     var oldChild = getRealChild(oldRawChild);
  8177.  
  8178.     // mark v-show
  8179.     // so that the transition module can hand over the control to the directive
  8180.     if (child.data.directives && child.data.directives.some(function (d) { return d.name === 'show'; })) {
  8181.       child.data.show = true;
  8182.     }
  8183.  
  8184.     if (
  8185.       oldChild &&
  8186.       oldChild.data &&
  8187.       !isSameChild(child, oldChild) &&
  8188.       !isAsyncPlaceholder(oldChild) &&
  8189.       // #6687 component root is a comment node
  8190.       !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
  8191.     ) {
  8192.       // replace old child transition data with fresh one
  8193.       // important for dynamic transitions!
  8194.       var oldData = oldChild.data.transition = extend({}, data);
  8195.       // handle transition mode
  8196.       if (mode === 'out-in') {
  8197.         // return placeholder node and queue update when leave finishes
  8198.         this._leaving = true;
  8199.         mergeVNodeHook(oldData, 'afterLeave', function () {
  8200.           this$1._leaving = false;
  8201.           this$1.$forceUpdate();
  8202.         });
  8203.         return placeholder(h, rawChild)
  8204.       } else if (mode === 'in-out') {
  8205.         if (isAsyncPlaceholder(child)) {
  8206.           return oldRawChild
  8207.         }
  8208.         var delayedLeave;
  8209.         var performLeave = function () { delayedLeave(); };
  8210.         mergeVNodeHook(data, 'afterEnter', performLeave);
  8211.         mergeVNodeHook(data, 'enterCancelled', performLeave);
  8212.         mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
  8213.       }
  8214.     }
  8215.  
  8216.     return rawChild
  8217.   }
  8218. };
  8219.  
  8220. /*  */
  8221.  
  8222. // Provides transition support for list items.
  8223. // supports move transitions using the FLIP technique.
  8224.  
  8225. // Because the vdom's children update algorithm is "unstable" - i.e.
  8226. // it doesn't guarantee the relative positioning of removed elements,
  8227. // we force transition-group to update its children into two passes:
  8228. // in the first pass, we remove all nodes that need to be removed,
  8229. // triggering their leaving transition; in the second pass, we insert/move
  8230. // into the final desired state. This way in the second pass removed
  8231. // nodes will remain where they should be.
  8232.  
  8233. var props = extend({
  8234.   tag: String,
  8235.   moveClass: String
  8236. }, transitionProps);
  8237.  
  8238. delete props.mode;
  8239.  
  8240. var TransitionGroup = {
  8241.   props: props,
  8242.  
  8243.   render: function render (h) {
  8244.     var tag = this.tag || this.$vnode.data.tag || 'span';
  8245.     var map = Object.create(null);
  8246.     var prevChildren = this.prevChildren = this.children;
  8247.     var rawChildren = this.$slots.default || [];
  8248.     var children = this.children = [];
  8249.     var transitionData = extractTransitionData(this);
  8250.  
  8251.     for (var i = 0; i < rawChildren.length; i++) {
  8252.       var c = rawChildren[i];
  8253.       if (c.tag) {
  8254.         if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
  8255.           children.push(c);
  8256.           map[c.key] = c
  8257.           ;(c.data || (c.data = {})).transition = transitionData;
  8258.         } else {
  8259.           var opts = c.componentOptions;
  8260.           var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
  8261.           warn(("<transition-group> children must be keyed: <" + name + ">"));
  8262.         }
  8263.       }
  8264.     }
  8265.  
  8266.     if (prevChildren) {
  8267.       var kept = [];
  8268.       var removed = [];
  8269.       for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
  8270.         var c$1 = prevChildren[i$1];
  8271.         c$1.data.transition = transitionData;
  8272.         c$1.data.pos = c$1.elm.getBoundingClientRect();
  8273.         if (map[c$1.key]) {
  8274.           kept.push(c$1);
  8275.         } else {
  8276.           removed.push(c$1);
  8277.         }
  8278.       }
  8279.       this.kept = h(tag, null, kept);
  8280.       this.removed = removed;
  8281.     }
  8282.  
  8283.     return h(tag, null, children)
  8284.   },
  8285.  
  8286.   beforeUpdate: function beforeUpdate () {
  8287.     // force removing pass
  8288.     this.__patch__(
  8289.       this._vnode,
  8290.       this.kept,
  8291.       false, // hydrating
  8292.       true // removeOnly (!important avoids unnecessary moves)
  8293.     );
  8294.     this._vnode = this.kept;
  8295.   },
  8296.  
  8297.   updated: function updated () {
  8298.     var children = this.prevChildren;
  8299.     var moveClass = this.moveClass || ((this.name || 'v') + '-move');
  8300.     if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
  8301.       return
  8302.     }
  8303.  
  8304.     // we divide the work into three loops to avoid mixing DOM reads and writes
  8305.     // in each iteration - which helps prevent layout thrashing.
  8306.     children.forEach(callPendingCbs);
  8307.     children.forEach(recordPosition);
  8308.     children.forEach(applyTranslation);
  8309.  
  8310.     // force reflow to put everything in position
  8311.     // assign to this to avoid being removed in tree-shaking
  8312.     // $flow-disable-line
  8313.     this._reflow = document.body.offsetHeight;
  8314.  
  8315.     children.forEach(function (c) {
  8316.       if (c.data.moved) {
  8317.         var el = c.elm;
  8318.         var s = el.style;
  8319.         addTransitionClass(el, moveClass);
  8320.         s.transform = s.WebkitTransform = s.transitionDuration = '';
  8321.         el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
  8322.           if (!e || /transform$/.test(e.propertyName)) {
  8323.             el.removeEventListener(transitionEndEvent, cb);
  8324.             el._moveCb = null;
  8325.             removeTransitionClass(el, moveClass);
  8326.           }
  8327.         });
  8328.       }
  8329.     });
  8330.   },
  8331.  
  8332.   methods: {
  8333.     hasMove: function hasMove (el, moveClass) {
  8334.       /* istanbul ignore if */
  8335.       if (!hasTransition) {
  8336.         return false
  8337.       }
  8338.       /* istanbul ignore if */
  8339.       if (this._hasMove) {
  8340.         return this._hasMove
  8341.       }
  8342.       // Detect whether an element with the move class applied has
  8343.       // CSS transitions. Since the element may be inside an entering
  8344.       // transition at this very moment, we make a clone of it and remove
  8345.       // all other transition classes applied to ensure only the move class
  8346.       // is applied.
  8347.       var clone = el.cloneNode();
  8348.       if (el._transitionClasses) {
  8349.         el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
  8350.       }
  8351.       addClass(clone, moveClass);
  8352.       clone.style.display = 'none';
  8353.       this.$el.appendChild(clone);
  8354.       var info = getTransitionInfo(clone);
  8355.       this.$el.removeChild(clone);
  8356.       return (this._hasMove = info.hasTransform)
  8357.     }
  8358.   }
  8359. };
  8360.  
  8361. function callPendingCbs (c) {
  8362.   /* istanbul ignore if */
  8363.   if (c.elm._moveCb) {
  8364.     c.elm._moveCb();
  8365.   }
  8366.   /* istanbul ignore if */
  8367.   if (c.elm._enterCb) {
  8368.     c.elm._enterCb();
  8369.   }
  8370. }
  8371.  
  8372. function recordPosition (c) {
  8373.   c.data.newPos = c.elm.getBoundingClientRect();
  8374. }
  8375.  
  8376. function applyTranslation (c) {
  8377.   var oldPos = c.data.pos;
  8378.   var newPos = c.data.newPos;
  8379.   var dx = oldPos.left - newPos.left;
  8380.   var dy = oldPos.top - newPos.top;
  8381.   if (dx || dy) {
  8382.     c.data.moved = true;
  8383.     var s = c.elm.style;
  8384.     s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
  8385.     s.transitionDuration = '0s';
  8386.   }
  8387. }
  8388.  
  8389. var platformComponents = {
  8390.   Transition: Transition,
  8391.   TransitionGroup: TransitionGroup
  8392. };
  8393.  
  8394. /*  */
  8395.  
  8396. // install platform specific utils
  8397. Vue$3.config.mustUseProp = mustUseProp;
  8398. Vue$3.config.isReservedTag = isReservedTag;
  8399. Vue$3.config.isReservedAttr = isReservedAttr;
  8400. Vue$3.config.getTagNamespace = getTagNamespace;
  8401. Vue$3.config.isUnknownElement = isUnknownElement;
  8402.  
  8403. // install platform runtime directives & components
  8404. extend(Vue$3.options.directives, platformDirectives);
  8405. extend(Vue$3.options.components, platformComponents);
  8406.  
  8407. // install platform patch function
  8408. Vue$3.prototype.__patch__ = inBrowser ? patch : noop;
  8409.  
  8410. // public mount method
  8411. Vue$3.prototype.$mount = function (
  8412.   el,
  8413.   hydrating
  8414. ) {
  8415.   el = el && inBrowser ? query(el) : undefined;
  8416.   return mountComponent(this, el, hydrating)
  8417. };
  8418.  
  8419. // devtools global hook
  8420. /* istanbul ignore next */
  8421. Vue$3.nextTick(function () {
  8422.   if (config.devtools) {
  8423.     if (devtools) {
  8424.       devtools.emit('init', Vue$3);
  8425.     } else if ("development" !== 'production' && isChrome) {
  8426.       console[console.info ? 'info' : 'log'](
  8427.         'Download the Vue Devtools extension for a better development experience:\n' +
  8428.         'https://github.com/vuejs/vue-devtools'
  8429.       );
  8430.     }
  8431.   }
  8432.   if ("development" !== 'production' &&
  8433.     config.productionTip !== false &&
  8434.     inBrowser && typeof console !== 'undefined'
  8435.   ) {
  8436.     console[console.info ? 'info' : 'log'](
  8437.       "You are running Vue in development mode.\n" +
  8438.       "Make sure to turn on production mode when deploying for production.\n" +
  8439.       "See more tips at https://vuejs.org/guide/deployment.html"
  8440.     );
  8441.   }
  8442. }, 0);
  8443.  
  8444. /*  */
  8445.  
  8446. var defaultTagRE = /\{\{((?:.|\n)+?)\}\}/g;
  8447. var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
  8448.  
  8449. var buildRegex = cached(function (delimiters) {
  8450.   var open = delimiters[0].replace(regexEscapeRE, '\\$&');
  8451.   var close = delimiters[1].replace(regexEscapeRE, '\\$&');
  8452.   return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
  8453. });
  8454.  
  8455.  
  8456.  
  8457. function parseText (
  8458.   text,
  8459.   delimiters
  8460. ) {
  8461.   var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
  8462.   if (!tagRE.test(text)) {
  8463.     return
  8464.   }
  8465.   var tokens = [];
  8466.   var rawTokens = [];
  8467.   var lastIndex = tagRE.lastIndex = 0;
  8468.   var match, index, tokenValue;
  8469.   while ((match = tagRE.exec(text))) {
  8470.     index = match.index;
  8471.     // push text token
  8472.     if (index > lastIndex) {
  8473.       rawTokens.push(tokenValue = text.slice(lastIndex, index));
  8474.       tokens.push(JSON.stringify(tokenValue));
  8475.     }
  8476.     // tag token
  8477.     var exp = parseFilters(match[1].trim());
  8478.     tokens.push(("_s(" + exp + ")"));
  8479.     rawTokens.push({ '@binding': exp });
  8480.     lastIndex = index + match[0].length;
  8481.   }
  8482.   if (lastIndex < text.length) {
  8483.     rawTokens.push(tokenValue = text.slice(lastIndex));
  8484.     tokens.push(JSON.stringify(tokenValue));
  8485.   }
  8486.   return {
  8487.     expression: tokens.join('+'),
  8488.     tokens: rawTokens
  8489.   }
  8490. }
  8491.  
  8492. /*  */
  8493.  
  8494. function transformNode (el, options) {
  8495.   var warn = options.warn || baseWarn;
  8496.   var staticClass = getAndRemoveAttr(el, 'class');
  8497.   if ("development" !== 'production' && staticClass) {
  8498.     var res = parseText(staticClass, options.delimiters);
  8499.     if (res) {
  8500.       warn(
  8501.         "class=\"" + staticClass + "\": " +
  8502.         'Interpolation inside attributes has been removed. ' +
  8503.         'Use v-bind or the colon shorthand instead. For example, ' +
  8504.         'instead of <div class="{{ val }}">, use <div :class="val">.'
  8505.       );
  8506.     }
  8507.   }
  8508.   if (staticClass) {
  8509.     el.staticClass = JSON.stringify(staticClass);
  8510.   }
  8511.   var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
  8512.   if (classBinding) {
  8513.     el.classBinding = classBinding;
  8514.   }
  8515. }
  8516.  
  8517. function genData (el) {
  8518.   var data = '';
  8519.   if (el.staticClass) {
  8520.     data += "staticClass:" + (el.staticClass) + ",";
  8521.   }
  8522.   if (el.classBinding) {
  8523.     data += "class:" + (el.classBinding) + ",";
  8524.   }
  8525.   return data
  8526. }
  8527.  
  8528. var klass$1 = {
  8529.   staticKeys: ['staticClass'],
  8530.   transformNode: transformNode,
  8531.   genData: genData
  8532. };
  8533.  
  8534. /*  */
  8535.  
  8536. function transformNode$1 (el, options) {
  8537.   var warn = options.warn || baseWarn;
  8538.   var staticStyle = getAndRemoveAttr(el, 'style');
  8539.   if (staticStyle) {
  8540.     /* istanbul ignore if */
  8541.     {
  8542.       var res = parseText(staticStyle, options.delimiters);
  8543.       if (res) {
  8544.         warn(
  8545.           "style=\"" + staticStyle + "\": " +
  8546.           'Interpolation inside attributes has been removed. ' +
  8547.           'Use v-bind or the colon shorthand instead. For example, ' +
  8548.           'instead of <div style="{{ val }}">, use <div :style="val">.'
  8549.         );
  8550.       }
  8551.     }
  8552.     el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
  8553.   }
  8554.  
  8555.   var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
  8556.   if (styleBinding) {
  8557.     el.styleBinding = styleBinding;
  8558.   }
  8559. }
  8560.  
  8561. function genData$1 (el) {
  8562.   var data = '';
  8563.   if (el.staticStyle) {
  8564.     data += "staticStyle:" + (el.staticStyle) + ",";
  8565.   }
  8566.   if (el.styleBinding) {
  8567.     data += "style:(" + (el.styleBinding) + "),";
  8568.   }
  8569.   return data
  8570. }
  8571.  
  8572. var style$1 = {
  8573.   staticKeys: ['staticStyle'],
  8574.   transformNode: transformNode$1,
  8575.   genData: genData$1
  8576. };
  8577.  
  8578. /*  */
  8579.  
  8580. var decoder;
  8581.  
  8582. var he = {
  8583.   decode: function decode (html) {
  8584.     decoder = decoder || document.createElement('div');
  8585.     decoder.innerHTML = html;
  8586.     return decoder.textContent
  8587.   }
  8588. };
  8589.  
  8590. /*  */
  8591.  
  8592. var isUnaryTag = makeMap(
  8593.   'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
  8594.   'link,meta,param,source,track,wbr'
  8595. );
  8596.  
  8597. // Elements that you can, intentionally, leave open
  8598. // (and which close themselves)
  8599. var canBeLeftOpenTag = makeMap(
  8600.   'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
  8601. );
  8602.  
  8603. // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
  8604. // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
  8605. var isNonPhrasingTag = makeMap(
  8606.   'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
  8607.   'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
  8608.   'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
  8609.   'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
  8610.   'title,tr,track'
  8611. );
  8612.  
  8613. /**
  8614.  * Not type-checking this file because it's mostly vendor code.
  8615.  */
  8616.  
  8617. /*!
  8618.  * HTML Parser By John Resig (ejohn.org)
  8619.  * Modified by Juriy "kangax" Zaytsev
  8620.  * Original code by Erik Arvidsson, Mozilla Public License
  8621.  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  8622.  */
  8623.  
  8624. // Regular Expressions for parsing tags and attributes
  8625. var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
  8626. // could use https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
  8627. // but for Vue templates we can enforce a simple charset
  8628. var ncname = '[a-zA-Z_][\\w\\-\\.]*';
  8629. var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
  8630. var startTagOpen = new RegExp(("^<" + qnameCapture));
  8631. var startTagClose = /^\s*(\/?)>/;
  8632. var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
  8633. var doctype = /^<!DOCTYPE [^>]+>/i;
  8634. var comment = /^<!--/;
  8635. var conditionalComment = /^<!\[/;
  8636.  
  8637. var IS_REGEX_CAPTURING_BROKEN = false;
  8638. 'x'.replace(/x(.)?/g, function (m, g) {
  8639.   IS_REGEX_CAPTURING_BROKEN = g === '';
  8640. });
  8641.  
  8642. // Special Elements (can contain anything)
  8643. var isPlainTextElement = makeMap('script,style,textarea', true);
  8644. var reCache = {};
  8645.  
  8646. var decodingMap = {
  8647.   '&lt;': '<',
  8648.   '&gt;': '>',
  8649.   '&quot;': '"',
  8650.   '&amp;': '&',
  8651.   '&#10;': '\n',
  8652.   '&#9;': '\t'
  8653. };
  8654. var encodedAttr = /&(?:lt|gt|quot|amp);/g;
  8655. var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#10|#9);/g;
  8656.  
  8657. // #5992
  8658. var isIgnoreNewlineTag = makeMap('pre,textarea', true);
  8659. var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
  8660.  
  8661. function decodeAttr (value, shouldDecodeNewlines) {
  8662.   var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
  8663.   return value.replace(re, function (match) { return decodingMap[match]; })
  8664. }
  8665.  
  8666. function parseHTML (html, options) {
  8667.   var stack = [];
  8668.   var expectHTML = options.expectHTML;
  8669.   var isUnaryTag$$1 = options.isUnaryTag || no;
  8670.   var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
  8671.   var index = 0;
  8672.   var last, lastTag;
  8673.   while (html) {
  8674.     last = html;
  8675.     // Make sure we're not in a plaintext content element like script/style
  8676.     if (!lastTag || !isPlainTextElement(lastTag)) {
  8677.       var textEnd = html.indexOf('<');
  8678.       if (textEnd === 0) {
  8679.         // Comment:
  8680.         if (comment.test(html)) {
  8681.           var commentEnd = html.indexOf('-->');
  8682.  
  8683.           if (commentEnd >= 0) {
  8684.             if (options.shouldKeepComment) {
  8685.               options.comment(html.substring(4, commentEnd));
  8686.             }
  8687.             advance(commentEnd + 3);
  8688.             continue
  8689.           }
  8690.         }
  8691.  
  8692.         // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
  8693.         if (conditionalComment.test(html)) {
  8694.           var conditionalEnd = html.indexOf(']>');
  8695.  
  8696.           if (conditionalEnd >= 0) {
  8697.             advance(conditionalEnd + 2);
  8698.             continue
  8699.           }
  8700.         }
  8701.  
  8702.         // Doctype:
  8703.         var doctypeMatch = html.match(doctype);
  8704.         if (doctypeMatch) {
  8705.           advance(doctypeMatch[0].length);
  8706.           continue
  8707.         }
  8708.  
  8709.         // End tag:
  8710.         var endTagMatch = html.match(endTag);
  8711.         if (endTagMatch) {
  8712.           var curIndex = index;
  8713.           advance(endTagMatch[0].length);
  8714.           parseEndTag(endTagMatch[1], curIndex, index);
  8715.           continue
  8716.         }
  8717.  
  8718.         // Start tag:
  8719.         var startTagMatch = parseStartTag();
  8720.         if (startTagMatch) {
  8721.           handleStartTag(startTagMatch);
  8722.           if (shouldIgnoreFirstNewline(lastTag, html)) {
  8723.             advance(1);
  8724.           }
  8725.           continue
  8726.         }
  8727.       }
  8728.  
  8729.       var text = (void 0), rest = (void 0), next = (void 0);
  8730.       if (textEnd >= 0) {
  8731.         rest = html.slice(textEnd);
  8732.         while (
  8733.           !endTag.test(rest) &&
  8734.           !startTagOpen.test(rest) &&
  8735.           !comment.test(rest) &&
  8736.           !conditionalComment.test(rest)
  8737.         ) {
  8738.           // < in plain text, be forgiving and treat it as text
  8739.           next = rest.indexOf('<', 1);
  8740.           if (next < 0) { break }
  8741.           textEnd += next;
  8742.           rest = html.slice(textEnd);
  8743.         }
  8744.         text = html.substring(0, textEnd);
  8745.         advance(textEnd);
  8746.       }
  8747.  
  8748.       if (textEnd < 0) {
  8749.         text = html;
  8750.         html = '';
  8751.       }
  8752.  
  8753.       if (options.chars && text) {
  8754.         options.chars(text);
  8755.       }
  8756.     } else {
  8757.       var endTagLength = 0;
  8758.       var stackedTag = lastTag.toLowerCase();
  8759.       var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
  8760.       var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
  8761.         endTagLength = endTag.length;
  8762.         if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
  8763.           text = text
  8764.             .replace(/<!--([\s\S]*?)-->/g, '$1')
  8765.             .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
  8766.         }
  8767.         if (shouldIgnoreFirstNewline(stackedTag, text)) {
  8768.           text = text.slice(1);
  8769.         }
  8770.         if (options.chars) {
  8771.           options.chars(text);
  8772.         }
  8773.         return ''
  8774.       });
  8775.       index += html.length - rest$1.length;
  8776.       html = rest$1;
  8777.       parseEndTag(stackedTag, index - endTagLength, index);
  8778.     }
  8779.  
  8780.     if (html === last) {
  8781.       options.chars && options.chars(html);
  8782.       if ("development" !== 'production' && !stack.length && options.warn) {
  8783.         options.warn(("Mal-formatted tag at end of template: \"" + html + "\""));
  8784.       }
  8785.       break
  8786.     }
  8787.   }
  8788.  
  8789.   // Clean up any remaining tags
  8790.   parseEndTag();
  8791.  
  8792.   function advance (n) {
  8793.     index += n;
  8794.     html = html.substring(n);
  8795.   }
  8796.  
  8797.   function parseStartTag () {
  8798.     var start = html.match(startTagOpen);
  8799.     if (start) {
  8800.       var match = {
  8801.         tagName: start[1],
  8802.         attrs: [],
  8803.         start: index
  8804.       };
  8805.       advance(start[0].length);
  8806.       var end, attr;
  8807.       while (!(end = html.match(startTagClose)) && (attr = html.match(attribute))) {
  8808.         advance(attr[0].length);
  8809.         match.attrs.push(attr);
  8810.       }
  8811.       if (end) {
  8812.         match.unarySlash = end[1];
  8813.         advance(end[0].length);
  8814.         match.end = index;
  8815.         return match
  8816.       }
  8817.     }
  8818.   }
  8819.  
  8820.   function handleStartTag (match) {
  8821.     var tagName = match.tagName;
  8822.     var unarySlash = match.unarySlash;
  8823.  
  8824.     if (expectHTML) {
  8825.       if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
  8826.         parseEndTag(lastTag);
  8827.       }
  8828.       if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
  8829.         parseEndTag(tagName);
  8830.       }
  8831.     }
  8832.  
  8833.     var unary = isUnaryTag$$1(tagName) || !!unarySlash;
  8834.  
  8835.     var l = match.attrs.length;
  8836.     var attrs = new Array(l);
  8837.     for (var i = 0; i < l; i++) {
  8838.       var args = match.attrs[i];
  8839.       // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
  8840.       if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
  8841.         if (args[3] === '') { delete args[3]; }
  8842.         if (args[4] === '') { delete args[4]; }
  8843.         if (args[5] === '') { delete args[5]; }
  8844.       }
  8845.       var value = args[3] || args[4] || args[5] || '';
  8846.       var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
  8847.         ? options.shouldDecodeNewlinesForHref
  8848.         : options.shouldDecodeNewlines;
  8849.       attrs[i] = {
  8850.         name: args[1],
  8851.         value: decodeAttr(value, shouldDecodeNewlines)
  8852.       };
  8853.     }
  8854.  
  8855.     if (!unary) {
  8856.       stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs });
  8857.       lastTag = tagName;
  8858.     }
  8859.  
  8860.     if (options.start) {
  8861.       options.start(tagName, attrs, unary, match.start, match.end);
  8862.     }
  8863.   }
  8864.  
  8865.   function parseEndTag (tagName, start, end) {
  8866.     var pos, lowerCasedTagName;
  8867.     if (start == null) { start = index; }
  8868.     if (end == null) { end = index; }
  8869.  
  8870.     if (tagName) {
  8871.       lowerCasedTagName = tagName.toLowerCase();
  8872.     }
  8873.  
  8874.     // Find the closest opened tag of the same type
  8875.     if (tagName) {
  8876.       for (pos = stack.length - 1; pos >= 0; pos--) {
  8877.         if (stack[pos].lowerCasedTag === lowerCasedTagName) {
  8878.           break
  8879.         }
  8880.       }
  8881.     } else {
  8882.       // If no tag name is provided, clean shop
  8883.       pos = 0;
  8884.     }
  8885.  
  8886.     if (pos >= 0) {
  8887.       // Close all the open elements, up the stack
  8888.       for (var i = stack.length - 1; i >= pos; i--) {
  8889.         if ("development" !== 'production' &&
  8890.           (i > pos || !tagName) &&
  8891.           options.warn
  8892.         ) {
  8893.           options.warn(
  8894.             ("tag <" + (stack[i].tag) + "> has no matching end tag.")
  8895.           );
  8896.         }
  8897.         if (options.end) {
  8898.           options.end(stack[i].tag, start, end);
  8899.         }
  8900.       }
  8901.  
  8902.       // Remove the open elements from the stack
  8903.       stack.length = pos;
  8904.       lastTag = pos && stack[pos - 1].tag;
  8905.     } else if (lowerCasedTagName === 'br') {
  8906.       if (options.start) {
  8907.         options.start(tagName, [], true, start, end);
  8908.       }
  8909.     } else if (lowerCasedTagName === 'p') {
  8910.       if (options.start) {
  8911.         options.start(tagName, [], false, start, end);
  8912.       }
  8913.       if (options.end) {
  8914.         options.end(tagName, start, end);
  8915.       }
  8916.     }
  8917.   }
  8918. }
  8919.  
  8920. /*  */
  8921.  
  8922. var onRE = /^@|^v-on:/;
  8923. var dirRE = /^v-|^@|^:/;
  8924. var forAliasRE = /(.*?)\s+(?:in|of)\s+(.*)/;
  8925. var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
  8926. var stripParensRE = /^\(|\)$/g;
  8927.  
  8928. var argRE = /:(.*)$/;
  8929. var bindRE = /^:|^v-bind:/;
  8930. var modifierRE = /\.[^.]+/g;
  8931.  
  8932. var decodeHTMLCached = cached(he.decode);
  8933.  
  8934. // configurable state
  8935. var warn$2;
  8936. var delimiters;
  8937. var transforms;
  8938. var preTransforms;
  8939. var postTransforms;
  8940. var platformIsPreTag;
  8941. var platformMustUseProp;
  8942. var platformGetTagNamespace;
  8943.  
  8944.  
  8945.  
  8946. function createASTElement (
  8947.   tag,
  8948.   attrs,
  8949.   parent
  8950. ) {
  8951.   return {
  8952.     type: 1,
  8953.     tag: tag,
  8954.     attrsList: attrs,
  8955.     attrsMap: makeAttrsMap(attrs),
  8956.     parent: parent,
  8957.     children: []
  8958.   }
  8959. }
  8960.  
  8961. /**
  8962.  * Convert HTML string to AST.
  8963.  */
  8964. function parse (
  8965.   template,
  8966.   options
  8967. ) {
  8968.   warn$2 = options.warn || baseWarn;
  8969.  
  8970.   platformIsPreTag = options.isPreTag || no;
  8971.   platformMustUseProp = options.mustUseProp || no;
  8972.   platformGetTagNamespace = options.getTagNamespace || no;
  8973.  
  8974.   transforms = pluckModuleFunction(options.modules, 'transformNode');
  8975.   preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
  8976.   postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
  8977.  
  8978.   delimiters = options.delimiters;
  8979.  
  8980.   var stack = [];
  8981.   var preserveWhitespace = options.preserveWhitespace !== false;
  8982.   var root;
  8983.   var currentParent;
  8984.   var inVPre = false;
  8985.   var inPre = false;
  8986.   var warned = false;
  8987.  
  8988.   function warnOnce (msg) {
  8989.     if (!warned) {
  8990.       warned = true;
  8991.       warn$2(msg);
  8992.     }
  8993.   }
  8994.  
  8995.   function closeElement (element) {
  8996.     // check pre state
  8997.     if (element.pre) {
  8998.       inVPre = false;
  8999.     }
  9000.     if (platformIsPreTag(element.tag)) {
  9001.       inPre = false;
  9002.     }
  9003.     // apply post-transforms
  9004.     for (var i = 0; i < postTransforms.length; i++) {
  9005.       postTransforms[i](element, options);
  9006.     }
  9007.   }
  9008.  
  9009.   parseHTML(template, {
  9010.     warn: warn$2,
  9011.     expectHTML: options.expectHTML,
  9012.     isUnaryTag: options.isUnaryTag,
  9013.     canBeLeftOpenTag: options.canBeLeftOpenTag,
  9014.     shouldDecodeNewlines: options.shouldDecodeNewlines,
  9015.     shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
  9016.     shouldKeepComment: options.comments,
  9017.     start: function start (tag, attrs, unary) {
  9018.       // check namespace.
  9019.       // inherit parent ns if there is one
  9020.       var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
  9021.  
  9022.       // handle IE svg bug
  9023.       /* istanbul ignore if */
  9024.       if (isIE && ns === 'svg') {
  9025.         attrs = guardIESVGBug(attrs);
  9026.       }
  9027.  
  9028.       var element = createASTElement(tag, attrs, currentParent);
  9029.       if (ns) {
  9030.         element.ns = ns;
  9031.       }
  9032.  
  9033.       if (isForbiddenTag(element) && !isServerRendering()) {
  9034.         element.forbidden = true;
  9035.         "development" !== 'production' && warn$2(
  9036.           'Templates should only be responsible for mapping the state to the ' +
  9037.           'UI. Avoid placing tags with side-effects in your templates, such as ' +
  9038.           "<" + tag + ">" + ', as they will not be parsed.'
  9039.         );
  9040.       }
  9041.  
  9042.       // apply pre-transforms
  9043.       for (var i = 0; i < preTransforms.length; i++) {
  9044.         element = preTransforms[i](element, options) || element;
  9045.       }
  9046.  
  9047.       if (!inVPre) {
  9048.         processPre(element);
  9049.         if (element.pre) {
  9050.           inVPre = true;
  9051.         }
  9052.       }
  9053.       if (platformIsPreTag(element.tag)) {
  9054.         inPre = true;
  9055.       }
  9056.       if (inVPre) {
  9057.         processRawAttrs(element);
  9058.       } else if (!element.processed) {
  9059.         // structural directives
  9060.         processFor(element);
  9061.         processIf(element);
  9062.         processOnce(element);
  9063.         // element-scope stuff
  9064.         processElement(element, options);
  9065.       }
  9066.  
  9067.       function checkRootConstraints (el) {
  9068.         {
  9069.           if (el.tag === 'slot' || el.tag === 'template') {
  9070.             warnOnce(
  9071.               "Cannot use <" + (el.tag) + "> as component root element because it may " +
  9072.               'contain multiple nodes.'
  9073.             );
  9074.           }
  9075.           if (el.attrsMap.hasOwnProperty('v-for')) {
  9076.             warnOnce(
  9077.               'Cannot use v-for on stateful component root element because ' +
  9078.               'it renders multiple elements.'
  9079.             );
  9080.           }
  9081.         }
  9082.       }
  9083.  
  9084.       // tree management
  9085.       if (!root) {
  9086.         root = element;
  9087.         checkRootConstraints(root);
  9088.       } else if (!stack.length) {
  9089.         // allow root elements with v-if, v-else-if and v-else
  9090.         if (root.if && (element.elseif || element.else)) {
  9091.           checkRootConstraints(element);
  9092.           addIfCondition(root, {
  9093.             exp: element.elseif,
  9094.             block: element
  9095.           });
  9096.         } else {
  9097.           warnOnce(
  9098.             "Component template should contain exactly one root element. " +
  9099.             "If you are using v-if on multiple elements, " +
  9100.             "use v-else-if to chain them instead."
  9101.           );
  9102.         }
  9103.       }
  9104.       if (currentParent && !element.forbidden) {
  9105.         if (element.elseif || element.else) {
  9106.           processIfConditions(element, currentParent);
  9107.         } else if (element.slotScope) { // scoped slot
  9108.           currentParent.plain = false;
  9109.           var name = element.slotTarget || '"default"';(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
  9110.         } else {
  9111.           currentParent.children.push(element);
  9112.           element.parent = currentParent;
  9113.         }
  9114.       }
  9115.       if (!unary) {
  9116.         currentParent = element;
  9117.         stack.push(element);
  9118.       } else {
  9119.         closeElement(element);
  9120.       }
  9121.     },
  9122.  
  9123.     end: function end () {
  9124.       // remove trailing whitespace
  9125.       var element = stack[stack.length - 1];
  9126.       var lastNode = element.children[element.children.length - 1];
  9127.       if (lastNode && lastNode.type === 3 && lastNode.text === ' ' && !inPre) {
  9128.         element.children.pop();
  9129.       }
  9130.       // pop stack
  9131.       stack.length -= 1;
  9132.       currentParent = stack[stack.length - 1];
  9133.       closeElement(element);
  9134.     },
  9135.  
  9136.     chars: function chars (text) {
  9137.       if (!currentParent) {
  9138.         {
  9139.           if (text === template) {
  9140.             warnOnce(
  9141.               'Component template requires a root element, rather than just text.'
  9142.             );
  9143.           } else if ((text = text.trim())) {
  9144.             warnOnce(
  9145.               ("text \"" + text + "\" outside root element will be ignored.")
  9146.             );
  9147.           }
  9148.         }
  9149.         return
  9150.       }
  9151.       // IE textarea placeholder bug
  9152.       /* istanbul ignore if */
  9153.       if (isIE &&
  9154.         currentParent.tag === 'textarea' &&
  9155.         currentParent.attrsMap.placeholder === text
  9156.       ) {
  9157.         return
  9158.       }
  9159.       var children = currentParent.children;
  9160.       text = inPre || text.trim()
  9161.         ? isTextTag(currentParent) ? text : decodeHTMLCached(text)
  9162.         // only preserve whitespace if its not right after a starting tag
  9163.         : preserveWhitespace && children.length ? ' ' : '';
  9164.       if (text) {
  9165.         var res;
  9166.         if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
  9167.           children.push({
  9168.             type: 2,
  9169.             expression: res.expression,
  9170.             tokens: res.tokens,
  9171.             text: text
  9172.           });
  9173.         } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
  9174.           children.push({
  9175.             type: 3,
  9176.             text: text
  9177.           });
  9178.         }
  9179.       }
  9180.     },
  9181.     comment: function comment (text) {
  9182.       currentParent.children.push({
  9183.         type: 3,
  9184.         text: text,
  9185.         isComment: true
  9186.       });
  9187.     }
  9188.   });
  9189.   return root
  9190. }
  9191.  
  9192. function processPre (el) {
  9193.   if (getAndRemoveAttr(el, 'v-pre') != null) {
  9194.     el.pre = true;
  9195.   }
  9196. }
  9197.  
  9198. function processRawAttrs (el) {
  9199.   var l = el.attrsList.length;
  9200.   if (l) {
  9201.     var attrs = el.attrs = new Array(l);
  9202.     for (var i = 0; i < l; i++) {
  9203.       attrs[i] = {
  9204.         name: el.attrsList[i].name,
  9205.         value: JSON.stringify(el.attrsList[i].value)
  9206.       };
  9207.     }
  9208.   } else if (!el.pre) {
  9209.     // non root node in pre blocks with no attributes
  9210.     el.plain = true;
  9211.   }
  9212. }
  9213.  
  9214. function processElement (element, options) {
  9215.   processKey(element);
  9216.  
  9217.   // determine whether this is a plain element after
  9218.   // removing structural attributes
  9219.   element.plain = !element.key && !element.attrsList.length;
  9220.  
  9221.   processRef(element);
  9222.   processSlot(element);
  9223.   processComponent(element);
  9224.   for (var i = 0; i < transforms.length; i++) {
  9225.     element = transforms[i](element, options) || element;
  9226.   }
  9227.   processAttrs(element);
  9228. }
  9229.  
  9230. function processKey (el) {
  9231.   var exp = getBindingAttr(el, 'key');
  9232.   if (exp) {
  9233.     if ("development" !== 'production' && el.tag === 'template') {
  9234.       warn$2("<template> cannot be keyed. Place the key on real elements instead.");
  9235.     }
  9236.     el.key = exp;
  9237.   }
  9238. }
  9239.  
  9240. function processRef (el) {
  9241.   var ref = getBindingAttr(el, 'ref');
  9242.   if (ref) {
  9243.     el.ref = ref;
  9244.     el.refInFor = checkInFor(el);
  9245.   }
  9246. }
  9247.  
  9248. function processFor (el) {
  9249.   var exp;
  9250.   if ((exp = getAndRemoveAttr(el, 'v-for'))) {
  9251.     var res = parseFor(exp);
  9252.     if (res) {
  9253.       extend(el, res);
  9254.     } else {
  9255.       warn$2(
  9256.         ("Invalid v-for expression: " + exp)
  9257.       );
  9258.     }
  9259.   }
  9260. }
  9261.  
  9262. function parseFor (exp) {
  9263.   var inMatch = exp.match(forAliasRE);
  9264.   if (!inMatch) { return }
  9265.   var res = {};
  9266.   res.for = inMatch[2].trim();
  9267.   var alias = inMatch[1].trim().replace(stripParensRE, '');
  9268.   var iteratorMatch = alias.match(forIteratorRE);
  9269.   if (iteratorMatch) {
  9270.     res.alias = alias.replace(forIteratorRE, '');
  9271.     res.iterator1 = iteratorMatch[1].trim();
  9272.     if (iteratorMatch[2]) {
  9273.       res.iterator2 = iteratorMatch[2].trim();
  9274.     }
  9275.   } else {
  9276.     res.alias = alias;
  9277.   }
  9278.   return res
  9279. }
  9280.  
  9281. function processIf (el) {
  9282.   var exp = getAndRemoveAttr(el, 'v-if');
  9283.   if (exp) {
  9284.     el.if = exp;
  9285.     addIfCondition(el, {
  9286.       exp: exp,
  9287.       block: el
  9288.     });
  9289.   } else {
  9290.     if (getAndRemoveAttr(el, 'v-else') != null) {
  9291.       el.else = true;
  9292.     }
  9293.     var elseif = getAndRemoveAttr(el, 'v-else-if');
  9294.     if (elseif) {
  9295.       el.elseif = elseif;
  9296.     }
  9297.   }
  9298. }
  9299.  
  9300. function processIfConditions (el, parent) {
  9301.   var prev = findPrevElement(parent.children);
  9302.   if (prev && prev.if) {
  9303.     addIfCondition(prev, {
  9304.       exp: el.elseif,
  9305.       block: el
  9306.     });
  9307.   } else {
  9308.     warn$2(
  9309.       "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
  9310.       "used on element <" + (el.tag) + "> without corresponding v-if."
  9311.     );
  9312.   }
  9313. }
  9314.  
  9315. function findPrevElement (children) {
  9316.   var i = children.length;
  9317.   while (i--) {
  9318.     if (children[i].type === 1) {
  9319.       return children[i]
  9320.     } else {
  9321.       if ("development" !== 'production' && children[i].text !== ' ') {
  9322.         warn$2(
  9323.           "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
  9324.           "will be ignored."
  9325.         );
  9326.       }
  9327.       children.pop();
  9328.     }
  9329.   }
  9330. }
  9331.  
  9332. function addIfCondition (el, condition) {
  9333.   if (!el.ifConditions) {
  9334.     el.ifConditions = [];
  9335.   }
  9336.   el.ifConditions.push(condition);
  9337. }
  9338.  
  9339. function processOnce (el) {
  9340.   var once$$1 = getAndRemoveAttr(el, 'v-once');
  9341.   if (once$$1 != null) {
  9342.     el.once = true;
  9343.   }
  9344. }
  9345.  
  9346. function processSlot (el) {
  9347.   if (el.tag === 'slot') {
  9348.     el.slotName = getBindingAttr(el, 'name');
  9349.     if ("development" !== 'production' && el.key) {
  9350.       warn$2(
  9351.         "`key` does not work on <slot> because slots are abstract outlets " +
  9352.         "and can possibly expand into multiple elements. " +
  9353.         "Use the key on a wrapping element instead."
  9354.       );
  9355.     }
  9356.   } else {
  9357.     var slotScope;
  9358.     if (el.tag === 'template') {
  9359.       slotScope = getAndRemoveAttr(el, 'scope');
  9360.       /* istanbul ignore if */
  9361.       if ("development" !== 'production' && slotScope) {
  9362.         warn$2(
  9363.           "the \"scope\" attribute for scoped slots have been deprecated and " +
  9364.           "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
  9365.           "can also be used on plain elements in addition to <template> to " +
  9366.           "denote scoped slots.",
  9367.           true
  9368.         );
  9369.       }
  9370.       el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
  9371.     } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
  9372.       /* istanbul ignore if */
  9373.       if ("development" !== 'production' && el.attrsMap['v-for']) {
  9374.         warn$2(
  9375.           "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
  9376.           "(v-for takes higher priority). Use a wrapper <template> for the " +
  9377.           "scoped slot to make it clearer.",
  9378.           true
  9379.         );
  9380.       }
  9381.       el.slotScope = slotScope;
  9382.     }
  9383.     var slotTarget = getBindingAttr(el, 'slot');
  9384.     if (slotTarget) {
  9385.       el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
  9386.       // preserve slot as an attribute for native shadow DOM compat
  9387.       // only for non-scoped slots.
  9388.       if (el.tag !== 'template' && !el.slotScope) {
  9389.         addAttr(el, 'slot', slotTarget);
  9390.       }
  9391.     }
  9392.   }
  9393. }
  9394.  
  9395. function processComponent (el) {
  9396.   var binding;
  9397.   if ((binding = getBindingAttr(el, 'is'))) {
  9398.     el.component = binding;
  9399.   }
  9400.   if (getAndRemoveAttr(el, 'inline-template') != null) {
  9401.     el.inlineTemplate = true;
  9402.   }
  9403. }
  9404.  
  9405. function processAttrs (el) {
  9406.   var list = el.attrsList;
  9407.   var i, l, name, rawName, value, modifiers, isProp;
  9408.   for (i = 0, l = list.length; i < l; i++) {
  9409.     name = rawName = list[i].name;
  9410.     value = list[i].value;
  9411.     if (dirRE.test(name)) {
  9412.       // mark element as dynamic
  9413.       el.hasBindings = true;
  9414.       // modifiers
  9415.       modifiers = parseModifiers(name);
  9416.       if (modifiers) {
  9417.         name = name.replace(modifierRE, '');
  9418.       }
  9419.       if (bindRE.test(name)) { // v-bind
  9420.         name = name.replace(bindRE, '');
  9421.         value = parseFilters(value);
  9422.         isProp = false;
  9423.         if (modifiers) {
  9424.           if (modifiers.prop) {
  9425.             isProp = true;
  9426.             name = camelize(name);
  9427.             if (name === 'innerHtml') { name = 'innerHTML'; }
  9428.           }
  9429.           if (modifiers.camel) {
  9430.             name = camelize(name);
  9431.           }
  9432.           if (modifiers.sync) {
  9433.             addHandler(
  9434.               el,
  9435.               ("update:" + (camelize(name))),
  9436.               genAssignmentCode(value, "$event")
  9437.             );
  9438.           }
  9439.         }
  9440.         if (isProp || (
  9441.           !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
  9442.         )) {
  9443.           addProp(el, name, value);
  9444.         } else {
  9445.           addAttr(el, name, value);
  9446.         }
  9447.       } else if (onRE.test(name)) { // v-on
  9448.         name = name.replace(onRE, '');
  9449.         addHandler(el, name, value, modifiers, false, warn$2);
  9450.       } else { // normal directives
  9451.         name = name.replace(dirRE, '');
  9452.         // parse arg
  9453.         var argMatch = name.match(argRE);
  9454.         var arg = argMatch && argMatch[1];
  9455.         if (arg) {
  9456.           name = name.slice(0, -(arg.length + 1));
  9457.         }
  9458.         addDirective(el, name, rawName, value, arg, modifiers);
  9459.         if ("development" !== 'production' && name === 'model') {
  9460.           checkForAliasModel(el, value);
  9461.         }
  9462.       }
  9463.     } else {
  9464.       // literal attribute
  9465.       {
  9466.         var res = parseText(value, delimiters);
  9467.         if (res) {
  9468.           warn$2(
  9469.             name + "=\"" + value + "\": " +
  9470.             'Interpolation inside attributes has been removed. ' +
  9471.             'Use v-bind or the colon shorthand instead. For example, ' +
  9472.             'instead of <div id="{{ val }}">, use <div :id="val">.'
  9473.           );
  9474.         }
  9475.       }
  9476.       addAttr(el, name, JSON.stringify(value));
  9477.       // #6887 firefox doesn't update muted state if set via attribute
  9478.       // even immediately after element creation
  9479.       if (!el.component &&
  9480.           name === 'muted' &&
  9481.           platformMustUseProp(el.tag, el.attrsMap.type, name)) {
  9482.         addProp(el, name, 'true');
  9483.       }
  9484.     }
  9485.   }
  9486. }
  9487.  
  9488. function checkInFor (el) {
  9489.   var parent = el;
  9490.   while (parent) {
  9491.     if (parent.for !== undefined) {
  9492.       return true
  9493.     }
  9494.     parent = parent.parent;
  9495.   }
  9496.   return false
  9497. }
  9498.  
  9499. function parseModifiers (name) {
  9500.   var match = name.match(modifierRE);
  9501.   if (match) {
  9502.     var ret = {};
  9503.     match.forEach(function (m) { ret[m.slice(1)] = true; });
  9504.     return ret
  9505.   }
  9506. }
  9507.  
  9508. function makeAttrsMap (attrs) {
  9509.   var map = {};
  9510.   for (var i = 0, l = attrs.length; i < l; i++) {
  9511.     if (
  9512.       "development" !== 'production' &&
  9513.       map[attrs[i].name] && !isIE && !isEdge
  9514.     ) {
  9515.       warn$2('duplicate attribute: ' + attrs[i].name);
  9516.     }
  9517.     map[attrs[i].name] = attrs[i].value;
  9518.   }
  9519.   return map
  9520. }
  9521.  
  9522. // for script (e.g. type="x/template") or style, do not decode content
  9523. function isTextTag (el) {
  9524.   return el.tag === 'script' || el.tag === 'style'
  9525. }
  9526.  
  9527. function isForbiddenTag (el) {
  9528.   return (
  9529.     el.tag === 'style' ||
  9530.     (el.tag === 'script' && (
  9531.       !el.attrsMap.type ||
  9532.       el.attrsMap.type === 'text/javascript'
  9533.     ))
  9534.   )
  9535. }
  9536.  
  9537. var ieNSBug = /^xmlns:NS\d+/;
  9538. var ieNSPrefix = /^NS\d+:/;
  9539.  
  9540. /* istanbul ignore next */
  9541. function guardIESVGBug (attrs) {
  9542.   var res = [];
  9543.   for (var i = 0; i < attrs.length; i++) {
  9544.     var attr = attrs[i];
  9545.     if (!ieNSBug.test(attr.name)) {
  9546.       attr.name = attr.name.replace(ieNSPrefix, '');
  9547.       res.push(attr);
  9548.     }
  9549.   }
  9550.   return res
  9551. }
  9552.  
  9553. function checkForAliasModel (el, value) {
  9554.   var _el = el;
  9555.   while (_el) {
  9556.     if (_el.for && _el.alias === value) {
  9557.       warn$2(
  9558.         "<" + (el.tag) + " v-model=\"" + value + "\">: " +
  9559.         "You are binding v-model directly to a v-for iteration alias. " +
  9560.         "This will not be able to modify the v-for source array because " +
  9561.         "writing to the alias is like modifying a function local variable. " +
  9562.         "Consider using an array of objects and use v-model on an object property instead."
  9563.       );
  9564.     }
  9565.     _el = _el.parent;
  9566.   }
  9567. }
  9568.  
  9569. /*  */
  9570.  
  9571. /**
  9572.  * Expand input[v-model] with dyanmic type bindings into v-if-else chains
  9573.  * Turn this:
  9574.  *   <input v-model="data[type]" :type="type">
  9575.  * into this:
  9576.  *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
  9577.  *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
  9578.  *   <input v-else :type="type" v-model="data[type]">
  9579.  */
  9580.  
  9581. function preTransformNode (el, options) {
  9582.   if (el.tag === 'input') {
  9583.     var map = el.attrsMap;
  9584.     if (map['v-model'] && (map['v-bind:type'] || map[':type'])) {
  9585.       var typeBinding = getBindingAttr(el, 'type');
  9586.       var ifCondition = getAndRemoveAttr(el, 'v-if', true);
  9587.       var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
  9588.       var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
  9589.       var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
  9590.       // 1. checkbox
  9591.       var branch0 = cloneASTElement(el);
  9592.       // process for on the main node
  9593.       processFor(branch0);
  9594.       addRawAttr(branch0, 'type', 'checkbox');
  9595.       processElement(branch0, options);
  9596.       branch0.processed = true; // prevent it from double-processed
  9597.       branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
  9598.       addIfCondition(branch0, {
  9599.         exp: branch0.if,
  9600.         block: branch0
  9601.       });
  9602.       // 2. add radio else-if condition
  9603.       var branch1 = cloneASTElement(el);
  9604.       getAndRemoveAttr(branch1, 'v-for', true);
  9605.       addRawAttr(branch1, 'type', 'radio');
  9606.       processElement(branch1, options);
  9607.       addIfCondition(branch0, {
  9608.         exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
  9609.         block: branch1
  9610.       });
  9611.       // 3. other
  9612.       var branch2 = cloneASTElement(el);
  9613.       getAndRemoveAttr(branch2, 'v-for', true);
  9614.       addRawAttr(branch2, ':type', typeBinding);
  9615.       processElement(branch2, options);
  9616.       addIfCondition(branch0, {
  9617.         exp: ifCondition,
  9618.         block: branch2
  9619.       });
  9620.  
  9621.       if (hasElse) {
  9622.         branch0.else = true;
  9623.       } else if (elseIfCondition) {
  9624.         branch0.elseif = elseIfCondition;
  9625.       }
  9626.  
  9627.       return branch0
  9628.     }
  9629.   }
  9630. }
  9631.  
  9632. function cloneASTElement (el) {
  9633.   return createASTElement(el.tag, el.attrsList.slice(), el.parent)
  9634. }
  9635.  
  9636. var model$2 = {
  9637.   preTransformNode: preTransformNode
  9638. };
  9639.  
  9640. var modules$1 = [
  9641.   klass$1,
  9642.   style$1,
  9643.   model$2
  9644. ];
  9645.  
  9646. /*  */
  9647.  
  9648. function text (el, dir) {
  9649.   if (dir.value) {
  9650.     addProp(el, 'textContent', ("_s(" + (dir.value) + ")"));
  9651.   }
  9652. }
  9653.  
  9654. /*  */
  9655.  
  9656. function html (el, dir) {
  9657.   if (dir.value) {
  9658.     addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"));
  9659.   }
  9660. }
  9661.  
  9662. var directives$1 = {
  9663.   model: model,
  9664.   text: text,
  9665.   html: html
  9666. };
  9667.  
  9668. /*  */
  9669.  
  9670. var baseOptions = {
  9671.   expectHTML: true,
  9672.   modules: modules$1,
  9673.   directives: directives$1,
  9674.   isPreTag: isPreTag,
  9675.   isUnaryTag: isUnaryTag,
  9676.   mustUseProp: mustUseProp,
  9677.   canBeLeftOpenTag: canBeLeftOpenTag,
  9678.   isReservedTag: isReservedTag,
  9679.   getTagNamespace: getTagNamespace,
  9680.   staticKeys: genStaticKeys(modules$1)
  9681. };
  9682.  
  9683. /*  */
  9684.  
  9685. var isStaticKey;
  9686. var isPlatformReservedTag;
  9687.  
  9688. var genStaticKeysCached = cached(genStaticKeys$1);
  9689.  
  9690. /**
  9691.  * Goal of the optimizer: walk the generated template AST tree
  9692.  * and detect sub-trees that are purely static, i.e. parts of
  9693.  * the DOM that never needs to change.
  9694.  *
  9695.  * Once we detect these sub-trees, we can:
  9696.  *
  9697.  * 1. Hoist them into constants, so that we no longer need to
  9698.  *    create fresh nodes for them on each re-render;
  9699.  * 2. Completely skip them in the patching process.
  9700.  */
  9701. function optimize (root, options) {
  9702.   if (!root) { return }
  9703.   isStaticKey = genStaticKeysCached(options.staticKeys || '');
  9704.   isPlatformReservedTag = options.isReservedTag || no;
  9705.   // first pass: mark all non-static nodes.
  9706.   markStatic$1(root);
  9707.   // second pass: mark static roots.
  9708.   markStaticRoots(root, false);
  9709. }
  9710.  
  9711. function genStaticKeys$1 (keys) {
  9712.   return makeMap(
  9713.     'type,tag,attrsList,attrsMap,plain,parent,children,attrs' +
  9714.     (keys ? ',' + keys : '')
  9715.   )
  9716. }
  9717.  
  9718. function markStatic$1 (node) {
  9719.   node.static = isStatic(node);
  9720.   if (node.type === 1) {
  9721.     // do not make component slot content static. this avoids
  9722.     // 1. components not able to mutate slot nodes
  9723.     // 2. static slot content fails for hot-reloading
  9724.     if (
  9725.       !isPlatformReservedTag(node.tag) &&
  9726.       node.tag !== 'slot' &&
  9727.       node.attrsMap['inline-template'] == null
  9728.     ) {
  9729.       return
  9730.     }
  9731.     for (var i = 0, l = node.children.length; i < l; i++) {
  9732.       var child = node.children[i];
  9733.       markStatic$1(child);
  9734.       if (!child.static) {
  9735.         node.static = false;
  9736.       }
  9737.     }
  9738.     if (node.ifConditions) {
  9739.       for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
  9740.         var block = node.ifConditions[i$1].block;
  9741.         markStatic$1(block);
  9742.         if (!block.static) {
  9743.           node.static = false;
  9744.         }
  9745.       }
  9746.     }
  9747.   }
  9748. }
  9749.  
  9750. function markStaticRoots (node, isInFor) {
  9751.   if (node.type === 1) {
  9752.     if (node.static || node.once) {
  9753.       node.staticInFor = isInFor;
  9754.     }
  9755.     // For a node to qualify as a static root, it should have children that
  9756.     // are not just static text. Otherwise the cost of hoisting out will
  9757.     // outweigh the benefits and it's better off to just always render it fresh.
  9758.     if (node.static && node.children.length && !(
  9759.       node.children.length === 1 &&
  9760.       node.children[0].type === 3
  9761.     )) {
  9762.       node.staticRoot = true;
  9763.       return
  9764.     } else {
  9765.       node.staticRoot = false;
  9766.     }
  9767.     if (node.children) {
  9768.       for (var i = 0, l = node.children.length; i < l; i++) {
  9769.         markStaticRoots(node.children[i], isInFor || !!node.for);
  9770.       }
  9771.     }
  9772.     if (node.ifConditions) {
  9773.       for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
  9774.         markStaticRoots(node.ifConditions[i$1].block, isInFor);
  9775.       }
  9776.     }
  9777.   }
  9778. }
  9779.  
  9780. function isStatic (node) {
  9781.   if (node.type === 2) { // expression
  9782.     return false
  9783.   }
  9784.   if (node.type === 3) { // text
  9785.     return true
  9786.   }
  9787.   return !!(node.pre || (
  9788.     !node.hasBindings && // no dynamic bindings
  9789.     !node.if && !node.for && // not v-if or v-for or v-else
  9790.     !isBuiltInTag(node.tag) && // not a built-in
  9791.     isPlatformReservedTag(node.tag) && // not a component
  9792.     !isDirectChildOfTemplateFor(node) &&
  9793.     Object.keys(node).every(isStaticKey)
  9794.   ))
  9795. }
  9796.  
  9797. function isDirectChildOfTemplateFor (node) {
  9798.   while (node.parent) {
  9799.     node = node.parent;
  9800.     if (node.tag !== 'template') {
  9801.       return false
  9802.     }
  9803.     if (node.for) {
  9804.       return true
  9805.     }
  9806.   }
  9807.   return false
  9808. }
  9809.  
  9810. /*  */
  9811.  
  9812. var fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/;
  9813. var simplePathRE = /^\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?']|\[".*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*\s*$/;
  9814.  
  9815. // keyCode aliases
  9816. var keyCodes = {
  9817.   esc: 27,
  9818.   tab: 9,
  9819.   enter: 13,
  9820.   space: 32,
  9821.   up: 38,
  9822.   left: 37,
  9823.   right: 39,
  9824.   down: 40,
  9825.   'delete': [8, 46]
  9826. };
  9827.  
  9828. // #4868: modifiers that prevent the execution of the listener
  9829. // need to explicitly return null so that we can determine whether to remove
  9830. // the listener for .once
  9831. var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
  9832.  
  9833. var modifierCode = {
  9834.   stop: '$event.stopPropagation();',
  9835.   prevent: '$event.preventDefault();',
  9836.   self: genGuard("$event.target !== $event.currentTarget"),
  9837.   ctrl: genGuard("!$event.ctrlKey"),
  9838.   shift: genGuard("!$event.shiftKey"),
  9839.   alt: genGuard("!$event.altKey"),
  9840.   meta: genGuard("!$event.metaKey"),
  9841.   left: genGuard("'button' in $event && $event.button !== 0"),
  9842.   middle: genGuard("'button' in $event && $event.button !== 1"),
  9843.   right: genGuard("'button' in $event && $event.button !== 2")
  9844. };
  9845.  
  9846. function genHandlers (
  9847.   events,
  9848.   isNative,
  9849.   warn
  9850. ) {
  9851.   var res = isNative ? 'nativeOn:{' : 'on:{';
  9852.   for (var name in events) {
  9853.     res += "\"" + name + "\":" + (genHandler(name, events[name])) + ",";
  9854.   }
  9855.   return res.slice(0, -1) + '}'
  9856. }
  9857.  
  9858. function genHandler (
  9859.   name,
  9860.   handler
  9861. ) {
  9862.   if (!handler) {
  9863.     return 'function(){}'
  9864.   }
  9865.  
  9866.   if (Array.isArray(handler)) {
  9867.     return ("[" + (handler.map(function (handler) { return genHandler(name, handler); }).join(',')) + "]")
  9868.   }
  9869.  
  9870.   var isMethodPath = simplePathRE.test(handler.value);
  9871.   var isFunctionExpression = fnExpRE.test(handler.value);
  9872.  
  9873.   if (!handler.modifiers) {
  9874.     if (isMethodPath || isFunctionExpression) {
  9875.       return handler.value
  9876.     }
  9877.     /* istanbul ignore if */
  9878.     return ("function($event){" + (handler.value) + "}") // inline statement
  9879.   } else {
  9880.     var code = '';
  9881.     var genModifierCode = '';
  9882.     var keys = [];
  9883.     for (var key in handler.modifiers) {
  9884.       if (modifierCode[key]) {
  9885.         genModifierCode += modifierCode[key];
  9886.         // left/right
  9887.         if (keyCodes[key]) {
  9888.           keys.push(key);
  9889.         }
  9890.       } else if (key === 'exact') {
  9891.         var modifiers = (handler.modifiers);
  9892.         genModifierCode += genGuard(
  9893.           ['ctrl', 'shift', 'alt', 'meta']
  9894.             .filter(function (keyModifier) { return !modifiers[keyModifier]; })
  9895.             .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
  9896.             .join('||')
  9897.         );
  9898.       } else {
  9899.         keys.push(key);
  9900.       }
  9901.     }
  9902.     if (keys.length) {
  9903.       code += genKeyFilter(keys);
  9904.     }
  9905.     // Make sure modifiers like prevent and stop get executed after key filtering
  9906.     if (genModifierCode) {
  9907.       code += genModifierCode;
  9908.     }
  9909.     var handlerCode = isMethodPath
  9910.       ? handler.value + '($event)'
  9911.       : isFunctionExpression
  9912.         ? ("(" + (handler.value) + ")($event)")
  9913.         : handler.value;
  9914.     /* istanbul ignore if */
  9915.     return ("function($event){" + code + handlerCode + "}")
  9916.   }
  9917. }
  9918.  
  9919. function genKeyFilter (keys) {
  9920.   return ("if(!('button' in $event)&&" + (keys.map(genFilterCode).join('&&')) + ")return null;")
  9921. }
  9922.  
  9923. function genFilterCode (key) {
  9924.   var keyVal = parseInt(key, 10);
  9925.   if (keyVal) {
  9926.     return ("$event.keyCode!==" + keyVal)
  9927.   }
  9928.   var code = keyCodes[key];
  9929.   return (
  9930.     "_k($event.keyCode," +
  9931.     (JSON.stringify(key)) + "," +
  9932.     (JSON.stringify(code)) + "," +
  9933.     "$event.key)"
  9934.   )
  9935. }
  9936.  
  9937. /*  */
  9938.  
  9939. function on (el, dir) {
  9940.   if ("development" !== 'production' && dir.modifiers) {
  9941.     warn("v-on without argument does not support modifiers.");
  9942.   }
  9943.   el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
  9944. }
  9945.  
  9946. /*  */
  9947.  
  9948. function bind$1 (el, dir) {
  9949.   el.wrapData = function (code) {
  9950.     return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
  9951.   };
  9952. }
  9953.  
  9954. /*  */
  9955.  
  9956. var baseDirectives = {
  9957.   on: on,
  9958.   bind: bind$1,
  9959.   cloak: noop
  9960. };
  9961.  
  9962. /*  */
  9963.  
  9964. var CodegenState = function CodegenState (options) {
  9965.   this.options = options;
  9966.   this.warn = options.warn || baseWarn;
  9967.   this.transforms = pluckModuleFunction(options.modules, 'transformCode');
  9968.   this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
  9969.   this.directives = extend(extend({}, baseDirectives), options.directives);
  9970.   var isReservedTag = options.isReservedTag || no;
  9971.   this.maybeComponent = function (el) { return !isReservedTag(el.tag); };
  9972.   this.onceId = 0;
  9973.   this.staticRenderFns = [];
  9974. };
  9975.  
  9976.  
  9977.  
  9978. function generate (
  9979.   ast,
  9980.   options
  9981. ) {
  9982.   var state = new CodegenState(options);
  9983.   var code = ast ? genElement(ast, state) : '_c("div")';
  9984.   return {
  9985.     render: ("with(this){return " + code + "}"),
  9986.     staticRenderFns: state.staticRenderFns
  9987.   }
  9988. }
  9989.  
  9990. function genElement (el, state) {
  9991.   if (el.staticRoot && !el.staticProcessed) {
  9992.     return genStatic(el, state)
  9993.   } else if (el.once && !el.onceProcessed) {
  9994.     return genOnce(el, state)
  9995.   } else if (el.for && !el.forProcessed) {
  9996.     return genFor(el, state)
  9997.   } else if (el.if && !el.ifProcessed) {
  9998.     return genIf(el, state)
  9999.   } else if (el.tag === 'template' && !el.slotTarget) {
  10000.     return genChildren(el, state) || 'void 0'
  10001.   } else if (el.tag === 'slot') {
  10002.     return genSlot(el, state)
  10003.   } else {
  10004.     // component or element
  10005.     var code;
  10006.     if (el.component) {
  10007.       code = genComponent(el.component, el, state);
  10008.     } else {
  10009.       var data = el.plain ? undefined : genData$2(el, state);
  10010.  
  10011.       var children = el.inlineTemplate ? null : genChildren(el, state, true);
  10012.       code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
  10013.     }
  10014.     // module transforms
  10015.     for (var i = 0; i < state.transforms.length; i++) {
  10016.       code = state.transforms[i](el, code);
  10017.     }
  10018.     return code
  10019.   }
  10020. }
  10021.  
  10022. // hoist static sub-trees out
  10023. function genStatic (el, state) {
  10024.   el.staticProcessed = true;
  10025.   state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
  10026.   return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
  10027. }
  10028.  
  10029. // v-once
  10030. function genOnce (el, state) {
  10031.   el.onceProcessed = true;
  10032.   if (el.if && !el.ifProcessed) {
  10033.     return genIf(el, state)
  10034.   } else if (el.staticInFor) {
  10035.     var key = '';
  10036.     var parent = el.parent;
  10037.     while (parent) {
  10038.       if (parent.for) {
  10039.         key = parent.key;
  10040.         break
  10041.       }
  10042.       parent = parent.parent;
  10043.     }
  10044.     if (!key) {
  10045.       "development" !== 'production' && state.warn(
  10046.         "v-once can only be used inside v-for that is keyed. "
  10047.       );
  10048.       return genElement(el, state)
  10049.     }
  10050.     return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
  10051.   } else {
  10052.     return genStatic(el, state)
  10053.   }
  10054. }
  10055.  
  10056. function genIf (
  10057.   el,
  10058.   state,
  10059.   altGen,
  10060.   altEmpty
  10061. ) {
  10062.   el.ifProcessed = true; // avoid recursion
  10063.   return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
  10064. }
  10065.  
  10066. function genIfConditions (
  10067.   conditions,
  10068.   state,
  10069.   altGen,
  10070.   altEmpty
  10071. ) {
  10072.   if (!conditions.length) {
  10073.     return altEmpty || '_e()'
  10074.   }
  10075.  
  10076.   var condition = conditions.shift();
  10077.   if (condition.exp) {
  10078.     return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
  10079.   } else {
  10080.     return ("" + (genTernaryExp(condition.block)))
  10081.   }
  10082.  
  10083.   // v-if with v-once should generate code like (a)?_m(0):_m(1)
  10084.   function genTernaryExp (el) {
  10085.     return altGen
  10086.       ? altGen(el, state)
  10087.       : el.once
  10088.         ? genOnce(el, state)
  10089.         : genElement(el, state)
  10090.   }
  10091. }
  10092.  
  10093. function genFor (
  10094.   el,
  10095.   state,
  10096.   altGen,
  10097.   altHelper
  10098. ) {
  10099.   var exp = el.for;
  10100.   var alias = el.alias;
  10101.   var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
  10102.   var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
  10103.  
  10104.   if ("development" !== 'production' &&
  10105.     state.maybeComponent(el) &&
  10106.     el.tag !== 'slot' &&
  10107.     el.tag !== 'template' &&
  10108.     !el.key
  10109.   ) {
  10110.     state.warn(
  10111.       "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
  10112.       "v-for should have explicit keys. " +
  10113.       "See https://vuejs.org/guide/list.html#key for more info.",
  10114.       true /* tip */
  10115.     );
  10116.   }
  10117.  
  10118.   el.forProcessed = true; // avoid recursion
  10119.   return (altHelper || '_l') + "((" + exp + ")," +
  10120.     "function(" + alias + iterator1 + iterator2 + "){" +
  10121.       "return " + ((altGen || genElement)(el, state)) +
  10122.     '})'
  10123. }
  10124.  
  10125. function genData$2 (el, state) {
  10126.   var data = '{';
  10127.  
  10128.   // directives first.
  10129.   // directives may mutate the el's other properties before they are generated.
  10130.   var dirs = genDirectives(el, state);
  10131.   if (dirs) { data += dirs + ','; }
  10132.  
  10133.   // key
  10134.   if (el.key) {
  10135.     data += "key:" + (el.key) + ",";
  10136.   }
  10137.   // ref
  10138.   if (el.ref) {
  10139.     data += "ref:" + (el.ref) + ",";
  10140.   }
  10141.   if (el.refInFor) {
  10142.     data += "refInFor:true,";
  10143.   }
  10144.   // pre
  10145.   if (el.pre) {
  10146.     data += "pre:true,";
  10147.   }
  10148.   // record original tag name for components using "is" attribute
  10149.   if (el.component) {
  10150.     data += "tag:\"" + (el.tag) + "\",";
  10151.   }
  10152.   // module data generation functions
  10153.   for (var i = 0; i < state.dataGenFns.length; i++) {
  10154.     data += state.dataGenFns[i](el);
  10155.   }
  10156.   // attributes
  10157.   if (el.attrs) {
  10158.     data += "attrs:{" + (genProps(el.attrs)) + "},";
  10159.   }
  10160.   // DOM props
  10161.   if (el.props) {
  10162.     data += "domProps:{" + (genProps(el.props)) + "},";
  10163.   }
  10164.   // event handlers
  10165.   if (el.events) {
  10166.     data += (genHandlers(el.events, false, state.warn)) + ",";
  10167.   }
  10168.   if (el.nativeEvents) {
  10169.     data += (genHandlers(el.nativeEvents, true, state.warn)) + ",";
  10170.   }
  10171.   // slot target
  10172.   // only for non-scoped slots
  10173.   if (el.slotTarget && !el.slotScope) {
  10174.     data += "slot:" + (el.slotTarget) + ",";
  10175.   }
  10176.   // scoped slots
  10177.   if (el.scopedSlots) {
  10178.     data += (genScopedSlots(el.scopedSlots, state)) + ",";
  10179.   }
  10180.   // component v-model
  10181.   if (el.model) {
  10182.     data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
  10183.   }
  10184.   // inline-template
  10185.   if (el.inlineTemplate) {
  10186.     var inlineTemplate = genInlineTemplate(el, state);
  10187.     if (inlineTemplate) {
  10188.       data += inlineTemplate + ",";
  10189.     }
  10190.   }
  10191.   data = data.replace(/,$/, '') + '}';
  10192.   // v-bind data wrap
  10193.   if (el.wrapData) {
  10194.     data = el.wrapData(data);
  10195.   }
  10196.   // v-on data wrap
  10197.   if (el.wrapListeners) {
  10198.     data = el.wrapListeners(data);
  10199.   }
  10200.   return data
  10201. }
  10202.  
  10203. function genDirectives (el, state) {
  10204.   var dirs = el.directives;
  10205.   if (!dirs) { return }
  10206.   var res = 'directives:[';
  10207.   var hasRuntime = false;
  10208.   var i, l, dir, needRuntime;
  10209.   for (i = 0, l = dirs.length; i < l; i++) {
  10210.     dir = dirs[i];
  10211.     needRuntime = true;
  10212.     var gen = state.directives[dir.name];
  10213.     if (gen) {
  10214.       // compile-time directive that manipulates AST.
  10215.       // returns true if it also needs a runtime counterpart.
  10216.       needRuntime = !!gen(el, dir, state.warn);
  10217.     }
  10218.     if (needRuntime) {
  10219.       hasRuntime = true;
  10220.       res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:\"" + (dir.arg) + "\"") : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
  10221.     }
  10222.   }
  10223.   if (hasRuntime) {
  10224.     return res.slice(0, -1) + ']'
  10225.   }
  10226. }
  10227.  
  10228. function genInlineTemplate (el, state) {
  10229.   var ast = el.children[0];
  10230.   if ("development" !== 'production' && (
  10231.     el.children.length !== 1 || ast.type !== 1
  10232.   )) {
  10233.     state.warn('Inline-template components must have exactly one child element.');
  10234.   }
  10235.   if (ast.type === 1) {
  10236.     var inlineRenderFns = generate(ast, state.options);
  10237.     return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
  10238.   }
  10239. }
  10240.  
  10241. function genScopedSlots (
  10242.   slots,
  10243.   state
  10244. ) {
  10245.   return ("scopedSlots:_u([" + (Object.keys(slots).map(function (key) {
  10246.       return genScopedSlot(key, slots[key], state)
  10247.     }).join(',')) + "])")
  10248. }
  10249.  
  10250. function genScopedSlot (
  10251.   key,
  10252.   el,
  10253.   state
  10254. ) {
  10255.   if (el.for && !el.forProcessed) {
  10256.     return genForScopedSlot(key, el, state)
  10257.   }
  10258.   var fn = "function(" + (String(el.slotScope)) + "){" +
  10259.     "return " + (el.tag === 'template'
  10260.       ? el.if
  10261.         ? ((el.if) + "?" + (genChildren(el, state) || 'undefined') + ":undefined")
  10262.         : genChildren(el, state) || 'undefined'
  10263.       : genElement(el, state)) + "}";
  10264.   return ("{key:" + key + ",fn:" + fn + "}")
  10265. }
  10266.  
  10267. function genForScopedSlot (
  10268.   key,
  10269.   el,
  10270.   state
  10271. ) {
  10272.   var exp = el.for;
  10273.   var alias = el.alias;
  10274.   var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
  10275.   var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
  10276.   el.forProcessed = true; // avoid recursion
  10277.   return "_l((" + exp + ")," +
  10278.     "function(" + alias + iterator1 + iterator2 + "){" +
  10279.       "return " + (genScopedSlot(key, el, state)) +
  10280.     '})'
  10281. }
  10282.  
  10283. function genChildren (
  10284.   el,
  10285.   state,
  10286.   checkSkip,
  10287.   altGenElement,
  10288.   altGenNode
  10289. ) {
  10290.   var children = el.children;
  10291.   if (children.length) {
  10292.     var el$1 = children[0];
  10293.     // optimize single v-for
  10294.     if (children.length === 1 &&
  10295.       el$1.for &&
  10296.       el$1.tag !== 'template' &&
  10297.       el$1.tag !== 'slot'
  10298.     ) {
  10299.       return (altGenElement || genElement)(el$1, state)
  10300.     }
  10301.     var normalizationType = checkSkip
  10302.       ? getNormalizationType(children, state.maybeComponent)
  10303.       : 0;
  10304.     var gen = altGenNode || genNode;
  10305.     return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType ? ("," + normalizationType) : ''))
  10306.   }
  10307. }
  10308.  
  10309. // determine the normalization needed for the children array.
  10310. // 0: no normalization needed
  10311. // 1: simple normalization needed (possible 1-level deep nested array)
  10312. // 2: full normalization needed
  10313. function getNormalizationType (
  10314.   children,
  10315.   maybeComponent
  10316. ) {
  10317.   var res = 0;
  10318.   for (var i = 0; i < children.length; i++) {
  10319.     var el = children[i];
  10320.     if (el.type !== 1) {
  10321.       continue
  10322.     }
  10323.     if (needsNormalization(el) ||
  10324.         (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
  10325.       res = 2;
  10326.       break
  10327.     }
  10328.     if (maybeComponent(el) ||
  10329.         (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
  10330.       res = 1;
  10331.     }
  10332.   }
  10333.   return res
  10334. }
  10335.  
  10336. function needsNormalization (el) {
  10337.   return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
  10338. }
  10339.  
  10340. function genNode (node, state) {
  10341.   if (node.type === 1) {
  10342.     return genElement(node, state)
  10343.   } if (node.type === 3 && node.isComment) {
  10344.     return genComment(node)
  10345.   } else {
  10346.     return genText(node)
  10347.   }
  10348. }
  10349.  
  10350. function genText (text) {
  10351.   return ("_v(" + (text.type === 2
  10352.     ? text.expression // no need for () because already wrapped in _s()
  10353.     : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
  10354. }
  10355.  
  10356. function genComment (comment) {
  10357.   return ("_e(" + (JSON.stringify(comment.text)) + ")")
  10358. }
  10359.  
  10360. function genSlot (el, state) {
  10361.   var slotName = el.slotName || '"default"';
  10362.   var children = genChildren(el, state);
  10363.   var res = "_t(" + slotName + (children ? ("," + children) : '');
  10364.   var attrs = el.attrs && ("{" + (el.attrs.map(function (a) { return ((camelize(a.name)) + ":" + (a.value)); }).join(',')) + "}");
  10365.   var bind$$1 = el.attrsMap['v-bind'];
  10366.   if ((attrs || bind$$1) && !children) {
  10367.     res += ",null";
  10368.   }
  10369.   if (attrs) {
  10370.     res += "," + attrs;
  10371.   }
  10372.   if (bind$$1) {
  10373.     res += (attrs ? '' : ',null') + "," + bind$$1;
  10374.   }
  10375.   return res + ')'
  10376. }
  10377.  
  10378. // componentName is el.component, take it as argument to shun flow's pessimistic refinement
  10379. function genComponent (
  10380.   componentName,
  10381.   el,
  10382.   state
  10383. ) {
  10384.   var children = el.inlineTemplate ? null : genChildren(el, state, true);
  10385.   return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
  10386. }
  10387.  
  10388. function genProps (props) {
  10389.   var res = '';
  10390.   for (var i = 0; i < props.length; i++) {
  10391.     var prop = props[i];
  10392.     /* istanbul ignore if */
  10393.     {
  10394.       res += "\"" + (prop.name) + "\":" + (transformSpecialNewlines(prop.value)) + ",";
  10395.     }
  10396.   }
  10397.   return res.slice(0, -1)
  10398. }
  10399.  
  10400. // #3895, #4268
  10401. function transformSpecialNewlines (text) {
  10402.   return text
  10403.     .replace(/\u2028/g, '\\u2028')
  10404.     .replace(/\u2029/g, '\\u2029')
  10405. }
  10406.  
  10407. /*  */
  10408.  
  10409. // these keywords should not appear inside expressions, but operators like
  10410. // typeof, instanceof and in are allowed
  10411. var prohibitedKeywordRE = new RegExp('\\b' + (
  10412.   'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
  10413.   'super,throw,while,yield,delete,export,import,return,switch,default,' +
  10414.   'extends,finally,continue,debugger,function,arguments'
  10415. ).split(',').join('\\b|\\b') + '\\b');
  10416.  
  10417. // these unary operators should not be used as property/method names
  10418. var unaryOperatorsRE = new RegExp('\\b' + (
  10419.   'delete,typeof,void'
  10420. ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
  10421.  
  10422. // strip strings in expressions
  10423. var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
  10424.  
  10425. // detect problematic expressions in a template
  10426. function detectErrors (ast) {
  10427.   var errors = [];
  10428.   if (ast) {
  10429.     checkNode(ast, errors);
  10430.   }
  10431.   return errors
  10432. }
  10433.  
  10434. function checkNode (node, errors) {
  10435.   if (node.type === 1) {
  10436.     for (var name in node.attrsMap) {
  10437.       if (dirRE.test(name)) {
  10438.         var value = node.attrsMap[name];
  10439.         if (value) {
  10440.           if (name === 'v-for') {
  10441.             checkFor(node, ("v-for=\"" + value + "\""), errors);
  10442.           } else if (onRE.test(name)) {
  10443.             checkEvent(value, (name + "=\"" + value + "\""), errors);
  10444.           } else {
  10445.             checkExpression(value, (name + "=\"" + value + "\""), errors);
  10446.           }
  10447.         }
  10448.       }
  10449.     }
  10450.     if (node.children) {
  10451.       for (var i = 0; i < node.children.length; i++) {
  10452.         checkNode(node.children[i], errors);
  10453.       }
  10454.     }
  10455.   } else if (node.type === 2) {
  10456.     checkExpression(node.expression, node.text, errors);
  10457.   }
  10458. }
  10459.  
  10460. function checkEvent (exp, text, errors) {
  10461.   var stipped = exp.replace(stripStringRE, '');
  10462.   var keywordMatch = stipped.match(unaryOperatorsRE);
  10463.   if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {
  10464.     errors.push(
  10465.       "avoid using JavaScript unary operator as property name: " +
  10466.       "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim())
  10467.     );
  10468.   }
  10469.   checkExpression(exp, text, errors);
  10470. }
  10471.  
  10472. function checkFor (node, text, errors) {
  10473.   checkExpression(node.for || '', text, errors);
  10474.   checkIdentifier(node.alias, 'v-for alias', text, errors);
  10475.   checkIdentifier(node.iterator1, 'v-for iterator', text, errors);
  10476.   checkIdentifier(node.iterator2, 'v-for iterator', text, errors);
  10477. }
  10478.  
  10479. function checkIdentifier (
  10480.   ident,
  10481.   type,
  10482.   text,
  10483.   errors
  10484. ) {
  10485.   if (typeof ident === 'string') {
  10486.     try {
  10487.       new Function(("var " + ident + "=_"));
  10488.     } catch (e) {
  10489.       errors.push(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())));
  10490.     }
  10491.   }
  10492. }
  10493.  
  10494. function checkExpression (exp, text, errors) {
  10495.   try {
  10496.     new Function(("return " + exp));
  10497.   } catch (e) {
  10498.     var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
  10499.     if (keywordMatch) {
  10500.       errors.push(
  10501.         "avoid using JavaScript keyword as property name: " +
  10502.         "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim())
  10503.       );
  10504.     } else {
  10505.       errors.push(
  10506.         "invalid expression: " + (e.message) + " in\n\n" +
  10507.         "    " + exp + "\n\n" +
  10508.         "  Raw expression: " + (text.trim()) + "\n"
  10509.       );
  10510.     }
  10511.   }
  10512. }
  10513.  
  10514. /*  */
  10515.  
  10516. function createFunction (code, errors) {
  10517.   try {
  10518.     return new Function(code)
  10519.   } catch (err) {
  10520.     errors.push({ err: err, code: code });
  10521.     return noop
  10522.   }
  10523. }
  10524.  
  10525. function createCompileToFunctionFn (compile) {
  10526.   var cache = Object.create(null);
  10527.  
  10528.   return function compileToFunctions (
  10529.     template,
  10530.     options,
  10531.     vm
  10532.   ) {
  10533.     options = extend({}, options);
  10534.     var warn$$1 = options.warn || warn;
  10535.     delete options.warn;
  10536.  
  10537.     /* istanbul ignore if */
  10538.     {
  10539.       // detect possible CSP restriction
  10540.       try {
  10541.         new Function('return 1');
  10542.       } catch (e) {
  10543.         if (e.toString().match(/unsafe-eval|CSP/)) {
  10544.           warn$$1(
  10545.             'It seems you are using the standalone build of Vue.js in an ' +
  10546.             'environment with Content Security Policy that prohibits unsafe-eval. ' +
  10547.             'The template compiler cannot work in this environment. Consider ' +
  10548.             'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
  10549.             'templates into render functions.'
  10550.           );
  10551.         }
  10552.       }
  10553.     }
  10554.  
  10555.     // check cache
  10556.     var key = options.delimiters
  10557.       ? String(options.delimiters) + template
  10558.       : template;
  10559.     if (cache[key]) {
  10560.       return cache[key]
  10561.     }
  10562.  
  10563.     // compile
  10564.     var compiled = compile(template, options);
  10565.  
  10566.     // check compilation errors/tips
  10567.     {
  10568.       if (compiled.errors && compiled.errors.length) {
  10569.         warn$$1(
  10570.           "Error compiling template:\n\n" + template + "\n\n" +
  10571.           compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
  10572.           vm
  10573.         );
  10574.       }
  10575.       if (compiled.tips && compiled.tips.length) {
  10576.         compiled.tips.forEach(function (msg) { return tip(msg, vm); });
  10577.       }
  10578.     }
  10579.  
  10580.     // turn code into functions
  10581.     var res = {};
  10582.     var fnGenErrors = [];
  10583.     res.render = createFunction(compiled.render, fnGenErrors);
  10584.     res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
  10585.       return createFunction(code, fnGenErrors)
  10586.     });
  10587.  
  10588.     // check function generation errors.
  10589.     // this should only happen if there is a bug in the compiler itself.
  10590.     // mostly for codegen development use
  10591.     /* istanbul ignore if */
  10592.     {
  10593.       if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
  10594.         warn$$1(
  10595.           "Failed to generate render function:\n\n" +
  10596.           fnGenErrors.map(function (ref) {
  10597.             var err = ref.err;
  10598.             var code = ref.code;
  10599.  
  10600.             return ((err.toString()) + " in\n\n" + code + "\n");
  10601.         }).join('\n'),
  10602.           vm
  10603.         );
  10604.       }
  10605.     }
  10606.  
  10607.     return (cache[key] = res)
  10608.   }
  10609. }
  10610.  
  10611. /*  */
  10612.  
  10613. function createCompilerCreator (baseCompile) {
  10614.   return function createCompiler (baseOptions) {
  10615.     function compile (
  10616.       template,
  10617.       options
  10618.     ) {
  10619.       var finalOptions = Object.create(baseOptions);
  10620.       var errors = [];
  10621.       var tips = [];
  10622.       finalOptions.warn = function (msg, tip) {
  10623.         (tip ? tips : errors).push(msg);
  10624.       };
  10625.  
  10626.       if (options) {
  10627.         // merge custom modules
  10628.         if (options.modules) {
  10629.           finalOptions.modules =
  10630.             (baseOptions.modules || []).concat(options.modules);
  10631.         }
  10632.         // merge custom directives
  10633.         if (options.directives) {
  10634.           finalOptions.directives = extend(
  10635.             Object.create(baseOptions.directives || null),
  10636.             options.directives
  10637.           );
  10638.         }
  10639.         // copy other options
  10640.         for (var key in options) {
  10641.           if (key !== 'modules' && key !== 'directives') {
  10642.             finalOptions[key] = options[key];
  10643.           }
  10644.         }
  10645.       }
  10646.  
  10647.       var compiled = baseCompile(template, finalOptions);
  10648.       {
  10649.         errors.push.apply(errors, detectErrors(compiled.ast));
  10650.       }
  10651.       compiled.errors = errors;
  10652.       compiled.tips = tips;
  10653.       return compiled
  10654.     }
  10655.  
  10656.     return {
  10657.       compile: compile,
  10658.       compileToFunctions: createCompileToFunctionFn(compile)
  10659.     }
  10660.   }
  10661. }
  10662.  
  10663. /*  */
  10664.  
  10665. // `createCompilerCreator` allows creating compilers that use alternative
  10666. // parser/optimizer/codegen, e.g the SSR optimizing compiler.
  10667. // Here we just export a default compiler using the default parts.
  10668. var createCompiler = createCompilerCreator(function baseCompile (
  10669.   template,
  10670.   options
  10671. ) {
  10672.   var ast = parse(template.trim(), options);
  10673.   if (options.optimize !== false) {
  10674.     optimize(ast, options);
  10675.   }
  10676.   var code = generate(ast, options);
  10677.   return {
  10678.     ast: ast,
  10679.     render: code.render,
  10680.     staticRenderFns: code.staticRenderFns
  10681.   }
  10682. });
  10683.  
  10684. /*  */
  10685.  
  10686. var ref$1 = createCompiler(baseOptions);
  10687. var compileToFunctions = ref$1.compileToFunctions;
  10688.  
  10689. /*  */
  10690.  
  10691. // check whether current browser encodes a char inside attribute values
  10692. var div;
  10693. function getShouldDecode (href) {
  10694.   div = div || document.createElement('div');
  10695.   div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
  10696.   return div.innerHTML.indexOf('&#10;') > 0
  10697. }
  10698.  
  10699. // #3663: IE encodes newlines inside attribute values while other browsers don't
  10700. var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
  10701. // #6828: chrome encodes content in a[href]
  10702. var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
  10703.  
  10704. /*  */
  10705.  
  10706. var idToTemplate = cached(function (id) {
  10707.   var el = query(id);
  10708.   return el && el.innerHTML
  10709. });
  10710.  
  10711. var mount = Vue$3.prototype.$mount;
  10712. Vue$3.prototype.$mount = function (
  10713.   el,
  10714.   hydrating
  10715. ) {
  10716.   el = el && query(el);
  10717.  
  10718.   /* istanbul ignore if */
  10719.   if (el === document.body || el === document.documentElement) {
  10720.     "development" !== 'production' && warn(
  10721.       "Do not mount Vue to <html> or <body> - mount to normal elements instead."
  10722.     );
  10723.     return this
  10724.   }
  10725.  
  10726.   var options = this.$options;
  10727.   // resolve template/el and convert to render function
  10728.   if (!options.render) {
  10729.     var template = options.template;
  10730.     if (template) {
  10731.       if (typeof template === 'string') {
  10732.         if (template.charAt(0) === '#') {
  10733.           template = idToTemplate(template);
  10734.           /* istanbul ignore if */
  10735.           if ("development" !== 'production' && !template) {
  10736.             warn(
  10737.               ("Template element not found or is empty: " + (options.template)),
  10738.               this
  10739.             );
  10740.           }
  10741.         }
  10742.       } else if (template.nodeType) {
  10743.         template = template.innerHTML;
  10744.       } else {
  10745.         {
  10746.           warn('invalid template option:' + template, this);
  10747.         }
  10748.         return this
  10749.       }
  10750.     } else if (el) {
  10751.       template = getOuterHTML(el);
  10752.     }
  10753.     if (template) {
  10754.       /* istanbul ignore if */
  10755.       if ("development" !== 'production' && config.performance && mark) {
  10756.         mark('compile');
  10757.       }
  10758.  
  10759.       var ref = compileToFunctions(template, {
  10760.         shouldDecodeNewlines: shouldDecodeNewlines,
  10761.         shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
  10762.         delimiters: options.delimiters,
  10763.         comments: options.comments
  10764.       }, this);
  10765.       var render = ref.render;
  10766.       var staticRenderFns = ref.staticRenderFns;
  10767.       options.render = render;
  10768.       options.staticRenderFns = staticRenderFns;
  10769.  
  10770.       /* istanbul ignore if */
  10771.       if ("development" !== 'production' && config.performance && mark) {
  10772.         mark('compile end');
  10773.         measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
  10774.       }
  10775.     }
  10776.   }
  10777.   return mount.call(this, el, hydrating)
  10778. };
  10779.  
  10780. /**
  10781.  * Get outerHTML of elements, taking care
  10782.  * of SVG elements in IE as well.
  10783.  */
  10784. function getOuterHTML (el) {
  10785.   if (el.outerHTML) {
  10786.     return el.outerHTML
  10787.   } else {
  10788.     var container = document.createElement('div');
  10789.     container.appendChild(el.cloneNode(true));
  10790.     return container.innerHTML
  10791.   }
  10792. }
  10793.  
  10794. Vue$3.compile = compileToFunctions;
  10795.  
  10796. return Vue$3;
  10797.  
  10798. })));