Use bundled Vue libmc-ui

2 files changed, 1 insertions, 10074 deletions

diff --git a/app/assets/javascripts/lib/vue.js b/app/assets/javascripts/lib/vue.js
deleted file mode 100644
index efc62983910..00000000000
--- a/app/assets/javascripts/lib/vue.js
+++ /dev/null
@@ -1,10073 +0,0 @@
-/*!
- * Vue.js v1.0.26
- * (c) 2016 Evan You
- * Released under the MIT License.
- */
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global.Vue = factory());
-}(this, function () { 'use strict';
-
-  function set(obj, key, val) {
-    if (hasOwn(obj, key)) {
-      obj[key] = val;
-      return;
-    }
-    if (obj._isVue) {
-      set(obj._data, key, val);
-      return;
-    }
-    var ob = obj.__ob__;
-    if (!ob) {
-      obj[key] = val;
-      return;
-    }
-    ob.convert(key, val);
-    ob.dep.notify();
-    if (ob.vms) {
-      var i = ob.vms.length;
-      while (i--) {
-        var vm = ob.vms[i];
-        vm._proxy(key);
-        vm._digest();
-      }
-    }
-    return val;
-  }
-
-  /**
-   * Delete a property and trigger change if necessary.
-   *
-   * @param {Object} obj
-   * @param {String} key
-   */
-
-  function del(obj, key) {
-    if (!hasOwn(obj, key)) {
-      return;
-    }
-    delete obj[key];
-    var ob = obj.__ob__;
-    if (!ob) {
-      if (obj._isVue) {
-        delete obj._data[key];
-        obj._digest();
-      }
-      return;
-    }
-    ob.dep.notify();
-    if (ob.vms) {
-      var i = ob.vms.length;
-      while (i--) {
-        var vm = ob.vms[i];
-        vm._unproxy(key);
-        vm._digest();
-      }
-    }
-  }
-
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
-  /**
-   * Check whether the object has the property.
-   *
-   * @param {Object} obj
-   * @param {String} key
-   * @return {Boolean}
-   */
-
-  function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-  }
-
-  /**
-   * Check if an expression is a literal value.
-   *
-   * @param {String} exp
-   * @return {Boolean}
-   */
-
-  var literalValueRE = /^\s?(true|false|-?[\d\.]+|'[^']*'|"[^"]*")\s?$/;
-
-  function isLiteral(exp) {
-    return literalValueRE.test(exp);
-  }
-
-  /**
-   * Check if a string starts with $ or _
-   *
-   * @param {String} str
-   * @return {Boolean}
-   */
-
-  function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5F;
-  }
-
-  /**
-   * Guard text output, make sure undefined outputs
-   * empty string
-   *
-   * @param {*} value
-   * @return {String}
-   */
-
-  function _toString(value) {
-    return value == null ? '' : value.toString();
-  }
-
-  /**
-   * Check and convert possible numeric strings to numbers
-   * before setting back to data
-   *
-   * @param {*} value
-   * @return {*|Number}
-   */
-
-  function toNumber(value) {
-    if (typeof value !== 'string') {
-      return value;
-    } else {
-      var parsed = Number(value);
-      return isNaN(parsed) ? value : parsed;
-    }
-  }
-
-  /**
-   * Convert string boolean literals into real booleans.
-   *
-   * @param {*} value
-   * @return {*|Boolean}
-   */
-
-  function toBoolean(value) {
-    return value === 'true' ? true : value === 'false' ? false : value;
-  }
-
-  /**
-   * Strip quotes from a string
-   *
-   * @param {String} str
-   * @return {String | false}
-   */
-
-  function stripQuotes(str) {
-    var a = str.charCodeAt(0);
-    var b = str.charCodeAt(str.length - 1);
-    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
-  }
-
-  /**
-   * Camelize a hyphen-delmited string.
-   *
-   * @param {String} str
-   * @return {String}
-   */
-
-  var camelizeRE = /-(\w)/g;
-
-  function camelize(str) {
-    return str.replace(camelizeRE, toUpper);
-  }
-
-  function toUpper(_, c) {
-    return c ? c.toUpperCase() : '';
-  }
-
-  /**
-   * Hyphenate a camelCase string.
-   *
-   * @param {String} str
-   * @return {String}
-   */
-
-  var hyphenateRE = /([a-z\d])([A-Z])/g;
-
-  function hyphenate(str) {
-    return str.replace(hyphenateRE, '$1-$2').toLowerCase();
-  }
-
-  /**
-   * Converts hyphen/underscore/slash delimitered names into
-   * camelized classNames.
-   *
-   * e.g. my-component => MyComponent
-   *      some_else    => SomeElse
-   *      some/comp    => SomeComp
-   *
-   * @param {String} str
-   * @return {String}
-   */
-
-  var classifyRE = /(?:^|[-_\/])(\w)/g;
-
-  function classify(str) {
-    return str.replace(classifyRE, toUpper);
-  }
-
-  /**
-   * Simple bind, faster than native
-   *
-   * @param {Function} fn
-   * @param {Object} ctx
-   * @return {Function}
-   */
-
-  function bind(fn, ctx) {
-    return function (a) {
-      var l = arguments.length;
-      return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx);
-    };
-  }
-
-  /**
-   * Convert an Array-like object to a real Array.
-   *
-   * @param {Array-like} list
-   * @param {Number} [start] - start index
-   * @return {Array}
-   */
-
-  function toArray(list, start) {
-    start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
-    while (i--) {
-      ret[i] = list[i + start];
-    }
-    return ret;
-  }
-
-  /**
-   * Mix properties into target object.
-   *
-   * @param {Object} to
-   * @param {Object} from
-   */
-
-  function extend(to, from) {
-    var keys = Object.keys(from);
-    var i = keys.length;
-    while (i--) {
-      to[keys[i]] = from[keys[i]];
-    }
-    return to;
-  }
-
-  /**
-   * Quick object check - this is primarily used to tell
-   * Objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   *
-   * @param {*} obj
-   * @return {Boolean}
-   */
-
-  function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-  }
-
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   *
-   * @param {*} obj
-   * @return {Boolean}
-   */
-
-  var toString = Object.prototype.toString;
-  var OBJECT_STRING = '[object Object]';
-
-  function isPlainObject(obj) {
-    return toString.call(obj) === OBJECT_STRING;
-  }
-
-  /**
-   * Array type check.
-   *
-   * @param {*} obj
-   * @return {Boolean}
-   */
-
-  var isArray = Array.isArray;
-
-  /**
-   * Define a property.
-   *
-   * @param {Object} obj
-   * @param {String} key
-   * @param {*} val
-   * @param {Boolean} [enumerable]
-   */
-
-  function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
-  }
-
-  /**
-   * Debounce a function so it only gets called after the
-   * input stops arriving after the given wait period.
-   *
-   * @param {Function} func
-   * @param {Number} wait
-   * @return {Function} - the debounced function
-   */
-
-  function _debounce(func, wait) {
-    var timeout, args, context, timestamp, result;
-    var later = function later() {
-      var last = Date.now() - timestamp;
-      if (last < wait && last >= 0) {
-        timeout = setTimeout(later, wait - last);
-      } else {
-        timeout = null;
-        result = func.apply(context, args);
-        if (!timeout) context = args = null;
-      }
-    };
-    return function () {
-      context = this;
-      args = arguments;
-      timestamp = Date.now();
-      if (!timeout) {
-        timeout = setTimeout(later, wait);
-      }
-      return result;
-    };
-  }
-
-  /**
-   * Manual indexOf because it's slightly faster than
-   * native.
-   *
-   * @param {Array} arr
-   * @param {*} obj
-   */
-
-  function indexOf(arr, obj) {
-    var i = arr.length;
-    while (i--) {
-      if (arr[i] === obj) return i;
-    }
-    return -1;
-  }
-
-  /**
-   * Make a cancellable version of an async callback.
-   *
-   * @param {Function} fn
-   * @return {Function}
-   */
-
-  function cancellable(fn) {
-    var cb = function cb() {
-      if (!cb.cancelled) {
-        return fn.apply(this, arguments);
-      }
-    };
-    cb.cancel = function () {
-      cb.cancelled = true;
-    };
-    return cb;
-  }
-
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   *
-   * @param {*} a
-   * @param {*} b
-   * @return {Boolean}
-   */
-
-  function looseEqual(a, b) {
-    /* eslint-disable eqeqeq */
-    return a == b || (isObject(a) && isObject(b) ? JSON.stringify(a) === JSON.stringify(b) : false);
-    /* eslint-enable eqeqeq */
-  }
-
-  var hasProto = ('__proto__' in {});
-
-  // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined' && Object.prototype.toString.call(window) !== '[object Object]';
-
-  // detect devtools
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
-  // UA sniffing for working around browser-specific quirks
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  var isIE = UA && UA.indexOf('trident') > 0;
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isAndroid = UA && UA.indexOf('android') > 0;
-  var isIos = UA && /(iphone|ipad|ipod|ios)/i.test(UA);
-  var iosVersionMatch = isIos && UA.match(/os ([\d_]+)/);
-  var iosVersion = iosVersionMatch && iosVersionMatch[1].split('_');
-
-  // detecting iOS UIWebView by indexedDB
-  var hasMutationObserverBug = iosVersion && Number(iosVersion[0]) >= 9 && Number(iosVersion[1]) >= 3 && !window.indexedDB;
-
-  var transitionProp = undefined;
-  var transitionEndEvent = undefined;
-  var animationProp = undefined;
-  var animationEndEvent = undefined;
-
-  // Transition property/event sniffing
-  if (inBrowser && !isIE9) {
-    var isWebkitTrans = window.ontransitionend === undefined && window.onwebkittransitionend !== undefined;
-    var isWebkitAnim = window.onanimationend === undefined && window.onwebkitanimationend !== undefined;
-    transitionProp = isWebkitTrans ? 'WebkitTransition' : 'transition';
-    transitionEndEvent = isWebkitTrans ? 'webkitTransitionEnd' : 'transitionend';
-    animationProp = isWebkitAnim ? 'WebkitAnimation' : 'animation';
-    animationEndEvent = isWebkitAnim ? 'webkitAnimationEnd' : 'animationend';
-  }
-
-  /**
-   * Defer a task to execute it asynchronously. Ideally this
-   * should be executed as a microtask, so we leverage
-   * MutationObserver if it's available, and fallback to
-   * setTimeout(0).
-   *
-   * @param {Function} cb
-   * @param {Object} ctx
-   */
-
-  var nextTick = (function () {
-    var callbacks = [];
-    var pending = false;
-    var timerFunc;
-    function nextTickHandler() {
-      pending = false;
-      var copies = callbacks.slice(0);
-      callbacks = [];
-      for (var i = 0; i < copies.length; i++) {
-        copies[i]();
-      }
-    }
-
-    /* istanbul ignore if */
-    if (typeof MutationObserver !== 'undefined' && !hasMutationObserverBug) {
-      var counter = 1;
-      var observer = new MutationObserver(nextTickHandler);
-      var textNode = document.createTextNode(counter);
-      observer.observe(textNode, {
-        characterData: true
-      });
-      timerFunc = function () {
-        counter = (counter + 1) % 2;
-        textNode.data = counter;
-      };
-    } else {
-      // webpack attempts to inject a shim for setImmediate
-      // if it is used as a global, so we have to work around that to
-      // avoid bundling unnecessary code.
-      var context = inBrowser ? window : typeof global !== 'undefined' ? global : {};
-      timerFunc = context.setImmediate || setTimeout;
-    }
-    return function (cb, ctx) {
-      var func = ctx ? function () {
-        cb.call(ctx);
-      } : cb;
-      callbacks.push(func);
-      if (pending) return;
-      pending = true;
-      timerFunc(nextTickHandler, 0);
-    };
-  })();
-
-  var _Set = undefined;
-  /* istanbul ignore if */
-  if (typeof Set !== 'undefined' && Set.toString().match(/native code/)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = function () {
-      this.set = Object.create(null);
-    };
-    _Set.prototype.has = function (key) {
-      return this.set[key] !== undefined;
-    };
-    _Set.prototype.add = function (key) {
-      this.set[key] = 1;
-    };
-    _Set.prototype.clear = function () {
-      this.set = Object.create(null);
-    };
-  }
-
-  function Cache(limit) {
-    this.size = 0;
-    this.limit = limit;
-    this.head = this.tail = undefined;
-    this._keymap = Object.create(null);
-  }
-
-  var p = Cache.prototype;
-
-  /**
-   * Put <value> into the cache associated with <key>.
-   * Returns the entry which was removed to make room for
-   * the new entry. Otherwise undefined is returned.
-   * (i.e. if there was enough room already).
-   *
-   * @param {String} key
-   * @param {*} value
-   * @return {Entry|undefined}
-   */
-
-  p.put = function (key, value) {
-    var removed;
-
-    var entry = this.get(key, true);
-    if (!entry) {
-      if (this.size === this.limit) {
-        removed = this.shift();
-      }
-      entry = {
-        key: key
-      };
-      this._keymap[key] = entry;
-      if (this.tail) {
-        this.tail.newer = entry;
-        entry.older = this.tail;
-      } else {
-        this.head = entry;
-      }
-      this.tail = entry;
-      this.size++;
-    }
-    entry.value = value;
-
-    return removed;
-  };
-
-  /**
-   * Purge the least recently used (oldest) entry from the
-   * cache. Returns the removed entry or undefined if the
-   * cache was empty.
-   */
-
-  p.shift = function () {
-    var entry = this.head;
-    if (entry) {
-      this.head = this.head.newer;
-      this.head.older = undefined;
-      entry.newer = entry.older = undefined;
-      this._keymap[entry.key] = undefined;
-      this.size--;
-    }
-    return entry;
-  };
-
-  /**
-   * Get and register recent use of <key>. Returns the value
-   * associated with <key> or undefined if not in cache.
-   *
-   * @param {String} key
-   * @param {Boolean} returnEntry
-   * @return {Entry|*}
-   */
-
-  p.get = function (key, returnEntry) {
-    var entry = this._keymap[key];
-    if (entry === undefined) return;
-    if (entry === this.tail) {
-      return returnEntry ? entry : entry.value;
-    }
-    // HEAD--------------TAIL
-    //   <.older   .newer>
-    //  <--- add direction --
-    //   A  B  C  <D>  E
-    if (entry.newer) {
-      if (entry === this.head) {
-        this.head = entry.newer;
-      }
-      entry.newer.older = entry.older; // C <-- E.
-    }
-    if (entry.older) {
-      entry.older.newer = entry.newer; // C. --> E
-    }
-    entry.newer = undefined; // D --x
-    entry.older = this.tail; // D. --> E
-    if (this.tail) {
-      this.tail.newer = entry; // E. <-- D
-    }
-    this.tail = entry;
-    return returnEntry ? entry : entry.value;
-  };
-
-  var cache$1 = new Cache(1000);
-  var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g;
-  var reservedArgRE = /^in$|^-?\d+/;
-
-  /**
-   * Parser state
-   */
-
-  var str;
-  var dir;
-  var c;
-  var prev;
-  var i;
-  var l;
-  var lastFilterIndex;
-  var inSingle;
-  var inDouble;
-  var curly;
-  var square;
-  var paren;
-  /**
-   * Push a filter to the current directive object
-   */
-
-  function pushFilter() {
-    var exp = str.slice(lastFilterIndex, i).trim();
-    var filter;
-    if (exp) {
-      filter = {};
-      var tokens = exp.match(filterTokenRE);
-      filter.name = tokens[0];
-      if (tokens.length > 1) {
-        filter.args = tokens.slice(1).map(processFilterArg);
-      }
-    }
-    if (filter) {
-      (dir.filters = dir.filters || []).push(filter);
-    }
-    lastFilterIndex = i + 1;
-  }
-
-  /**
-   * Check if an argument is dynamic and strip quotes.
-   *
-   * @param {String} arg
-   * @return {Object}
-   */
-
-  function processFilterArg(arg) {
-    if (reservedArgRE.test(arg)) {
-      return {
-        value: toNumber(arg),
-        dynamic: false
-      };
-    } else {
-      var stripped = stripQuotes(arg);
-      var dynamic = stripped === arg;
-      return {
-        value: dynamic ? arg : stripped,
-        dynamic: dynamic
-      };
-    }
-  }
-
-  /**
-   * Parse a directive value and extract the expression
-   * and its filters into a descriptor.
-   *
-   * Example:
-   *
-   * "a + 1 | uppercase" will yield:
-   * {
-   *   expression: 'a + 1',
-   *   filters: [
-   *     { name: 'uppercase', args: null }
-   *   ]
-   * }
-   *
-   * @param {String} s
-   * @return {Object}
-   */
-
-  function parseDirective(s) {
-    var hit = cache$1.get(s);
-    if (hit) {
-      return hit;
-    }
-
-    // reset parser state
-    str = s;
-    inSingle = inDouble = false;
-    curly = square = paren = 0;
-    lastFilterIndex = 0;
-    dir = {};
-
-    for (i = 0, l = str.length; i < l; i++) {
-      prev = c;
-      c = str.charCodeAt(i);
-      if (inSingle) {
-        // check single quote
-        if (c === 0x27 && prev !== 0x5C) inSingle = !inSingle;
-      } else if (inDouble) {
-        // check double quote
-        if (c === 0x22 && prev !== 0x5C) inDouble = !inDouble;
-      } else if (c === 0x7C && // pipe
-      str.charCodeAt(i + 1) !== 0x7C && str.charCodeAt(i - 1) !== 0x7C) {
-        if (dir.expression == null) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
-          dir.expression = str.slice(0, i).trim();
-        } else {
-          // already has filter
-          pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22:
-            inDouble = true;break; // "
-          case 0x27:
-            inSingle = true;break; // '
-          case 0x28:
-            paren++;break; // (
-          case 0x29:
-            paren--;break; // )
-          case 0x5B:
-            square++;break; // [
-          case 0x5D:
-            square--;break; // ]
-          case 0x7B:
-            curly++;break; // {
-          case 0x7D:
-            curly--;break; // }
-        }
-      }
-    }
-
-    if (dir.expression == null) {
-      dir.expression = str.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    cache$1.put(s, dir);
-    return dir;
-  }
-
-var directive = Object.freeze({
-    parseDirective: parseDirective
-  });
-
-  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  var cache = undefined;
-  var tagRE = undefined;
-  var htmlRE = undefined;
-  /**
-   * Escape a string so it can be used in a RegExp
-   * constructor.
-   *
-   * @param {String} str
-   */
-
-  function escapeRegex(str) {
-    return str.replace(regexEscapeRE, '\\$&');
-  }
-
-  function compileRegex() {
-    var open = escapeRegex(config.delimiters[0]);
-    var close = escapeRegex(config.delimiters[1]);
-    var unsafeOpen = escapeRegex(config.unsafeDelimiters[0]);
-    var unsafeClose = escapeRegex(config.unsafeDelimiters[1]);
-    tagRE = new RegExp(unsafeOpen + '((?:.|\\n)+?)' + unsafeClose + '|' + open + '((?:.|\\n)+?)' + close, 'g');
-    htmlRE = new RegExp('^' + unsafeOpen + '((?:.|\\n)+?)' + unsafeClose + '$');
-    // reset cache
-    cache = new Cache(1000);
-  }
-
-  /**
-   * Parse a template text string into an array of tokens.
-   *
-   * @param {String} text
-   * @return {Array<Object> | null}
-   *               - {String} type
-   *               - {String} value
-   *               - {Boolean} [html]
-   *               - {Boolean} [oneTime]
-   */
-
-  function parseText(text) {
-    if (!cache) {
-      compileRegex();
-    }
-    var hit = cache.get(text);
-    if (hit) {
-      return hit;
-    }
-    if (!tagRE.test(text)) {
-      return null;
-    }
-    var tokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, html, value, first, oneTime;
-    /* eslint-disable no-cond-assign */
-    while (match = tagRE.exec(text)) {
-      /* eslint-enable no-cond-assign */
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        tokens.push({
-          value: text.slice(lastIndex, index)
-        });
-      }
-      // tag token
-      html = htmlRE.test(match[0]);
-      value = html ? match[1] : match[2];
-      first = value.charCodeAt(0);
-      oneTime = first === 42; // *
-      value = oneTime ? value.slice(1) : value;
-      tokens.push({
-        tag: true,
-        value: value.trim(),
-        html: html,
-        oneTime: oneTime
-      });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      tokens.push({
-        value: text.slice(lastIndex)
-      });
-    }
-    cache.put(text, tokens);
-    return tokens;
-  }
-
-  /**
-   * Format a list of tokens into an expression.
-   * e.g. tokens parsed from 'a {{b}} c' can be serialized
-   * into one single expression as '"a " + b + " c"'.
-   *
-   * @param {Array} tokens
-   * @param {Vue} [vm]
-   * @return {String}
-   */
-
-  function tokensToExp(tokens, vm) {
-    if (tokens.length > 1) {
-      return tokens.map(function (token) {
-        return formatToken(token, vm);
-      }).join('+');
-    } else {
-      return formatToken(tokens[0], vm, true);
-    }
-  }
-
-  /**
-   * Format a single token.
-   *
-   * @param {Object} token
-   * @param {Vue} [vm]
-   * @param {Boolean} [single]
-   * @return {String}
-   */
-
-  function formatToken(token, vm, single) {
-    return token.tag ? token.oneTime && vm ? '"' + vm.$eval(token.value) + '"' : inlineFilters(token.value, single) : '"' + token.value + '"';
-  }
-
-  /**
-   * For an attribute with multiple interpolation tags,
-   * e.g. attr="some-{{thing | filter}}", in order to combine
-   * the whole thing into a single watchable expression, we
-   * have to inline those filters. This function does exactly
-   * that. This is a bit hacky but it avoids heavy changes
-   * to directive parser and watcher mechanism.
-   *
-   * @param {String} exp
-   * @param {Boolean} single
-   * @return {String}
-   */
-
-  var filterRE = /[^|]\|[^|]/;
-  function inlineFilters(exp, single) {
-    if (!filterRE.test(exp)) {
-      return single ? exp : '(' + exp + ')';
-    } else {
-      var dir = parseDirective(exp);
-      if (!dir.filters) {
-        return '(' + exp + ')';
-      } else {
-        return 'this._applyFilters(' + dir.expression + // value
-        ',null,' + // oldValue (null for read)
-        JSON.stringify(dir.filters) + // filter descriptors
-        ',false)'; // write?
-      }
-    }
-  }
-
-var text = Object.freeze({
-    compileRegex: compileRegex,
-    parseText: parseText,
-    tokensToExp: tokensToExp
-  });
-
-  var delimiters = ['{{', '}}'];
-  var unsafeDelimiters = ['{{{', '}}}'];
-
-  var config = Object.defineProperties({
-
-    /**
-     * Whether to print debug messages.
-     * Also enables stack trace for warnings.
-     *
-     * @type {Boolean}
-     */
-
-    debug: false,
-
-    /**
-     * Whether to suppress warnings.
-     *
-     * @type {Boolean}
-     */
-
-    silent: false,
-
-    /**
-     * Whether to use async rendering.
-     */
-
-    async: true,
-
-    /**
-     * Whether to warn against errors caught when evaluating
-     * expressions.
-     */
-
-    warnExpressionErrors: true,
-
-    /**
-     * Whether to allow devtools inspection.
-     * Disabled by default in production builds.
-     */
-
-    devtools: 'development' !== 'production',
-
-    /**
-     * Internal flag to indicate the delimiters have been
-     * changed.
-     *
-     * @type {Boolean}
-     */
-
-    _delimitersChanged: true,
-
-    /**
-     * List of asset types that a component can own.
-     *
-     * @type {Array}
-     */
-
-    _assetTypes: ['component', 'directive', 'elementDirective', 'filter', 'transition', 'partial'],
-
-    /**
-     * prop binding modes
-     */
-
-    _propBindingModes: {
-      ONE_WAY: 0,
-      TWO_WAY: 1,
-      ONE_TIME: 2
-    },
-
-    /**
-     * Max circular updates allowed in a batcher flush cycle.
-     */
-
-    _maxUpdateCount: 100
-
-  }, {
-    delimiters: { /**
-                   * Interpolation delimiters. Changing these would trigger
-                   * the text parser to re-compile the regular expressions.
-                   *
-                   * @type {Array<String>}
-                   */
-
-      get: function get() {
-        return delimiters;
-      },
-      set: function set(val) {
-        delimiters = val;
-        compileRegex();
-      },
-      configurable: true,
-      enumerable: true
-    },
-    unsafeDelimiters: {
-      get: function get() {
-        return unsafeDelimiters;
-      },
-      set: function set(val) {
-        unsafeDelimiters = val;
-        compileRegex();
-      },
-      configurable: true,
-      enumerable: true
-    }
-  });
-
-  var warn = undefined;
-  var formatComponentName = undefined;
-
-  if ('development' !== 'production') {
-    (function () {
-      var hasConsole = typeof console !== 'undefined';
-
-      warn = function (msg, vm) {
-        if (hasConsole && !config.silent) {
-          console.error('[Vue warn]: ' + msg + (vm ? formatComponentName(vm) : ''));
-        }
-      };
-
-      formatComponentName = function (vm) {
-        var name = vm._isVue ? vm.$options.name : vm.name;
-        return name ? ' (found in component: <' + hyphenate(name) + '>)' : '';
-      };
-    })();
-  }
-
-  /**
-   * Append with transition.
-   *
-   * @param {Element} el
-   * @param {Element} target
-   * @param {Vue} vm
-   * @param {Function} [cb]
-   */
-
-  function appendWithTransition(el, target, vm, cb) {
-    applyTransition(el, 1, function () {
-      target.appendChild(el);
-    }, vm, cb);
-  }
-
-  /**
-   * InsertBefore with transition.
-   *
-   * @param {Element} el
-   * @param {Element} target
-   * @param {Vue} vm
-   * @param {Function} [cb]
-   */
-
-  function beforeWithTransition(el, target, vm, cb) {
-    applyTransition(el, 1, function () {
-      before(el, target);
-    }, vm, cb);
-  }
-
-  /**
-   * Remove with transition.
-   *
-   * @param {Element} el
-   * @param {Vue} vm
-   * @param {Function} [cb]
-   */
-
-  function removeWithTransition(el, vm, cb) {
-    applyTransition(el, -1, function () {
-      remove(el);
-    }, vm, cb);
-  }
-
-  /**
-   * Apply transitions with an operation callback.
-   *
-   * @param {Element} el
-   * @param {Number} direction
-   *                  1: enter
-   *                 -1: leave
-   * @param {Function} op - the actual DOM operation
-   * @param {Vue} vm
-   * @param {Function} [cb]
-   */
-
-  function applyTransition(el, direction, op, vm, cb) {
-    var transition = el.__v_trans;
-    if (!transition ||
-    // skip if there are no js hooks and CSS transition is
-    // not supported
-    !transition.hooks && !transitionEndEvent ||
-    // skip transitions for initial compile
-    !vm._isCompiled ||
-    // if the vm is being manipulated by a parent directive
-    // during the parent's compilation phase, skip the
-    // animation.
-    vm.$parent && !vm.$parent._isCompiled) {
-      op();
-      if (cb) cb();
-      return;
-    }
-    var action = direction > 0 ? 'enter' : 'leave';
-    transition[action](op, cb);
-  }
-
-var transition = Object.freeze({
-    appendWithTransition: appendWithTransition,
-    beforeWithTransition: beforeWithTransition,
-    removeWithTransition: removeWithTransition,
-    applyTransition: applyTransition
-  });
-
-  /**
-   * Query an element selector if it's not an element already.
-   *
-   * @param {String|Element} el
-   * @return {Element}
-   */
-
-  function query(el) {
-    if (typeof el === 'string') {
-      var selector = el;
-      el = document.querySelector(el);
-      if (!el) {
-        'development' !== 'production' && warn('Cannot find element: ' + selector);
-      }
-    }
-    return el;
-  }
-
-  /**
-   * Check if a node is in the document.
-   * Note: document.documentElement.contains should work here
-   * but always returns false for comment nodes in phantomjs,
-   * making unit tests difficult. This is fixed by doing the
-   * contains() check on the node's parentNode instead of
-   * the node itself.
-   *
-   * @param {Node} node
-   * @return {Boolean}
-   */
-
-  function inDoc(node) {
-    if (!node) return false;
-    var doc = node.ownerDocument.documentElement;
-    var parent = node.parentNode;
-    return doc === node || doc === parent || !!(parent && parent.nodeType === 1 && doc.contains(parent));
-  }
-
-  /**
-   * Get and remove an attribute from a node.
-   *
-   * @param {Node} node
-   * @param {String} _attr
-   */
-
-  function getAttr(node, _attr) {
-    var val = node.getAttribute(_attr);
-    if (val !== null) {
-      node.removeAttribute(_attr);
-    }
-    return val;
-  }
-
-  /**
-   * Get an attribute with colon or v-bind: prefix.
-   *
-   * @param {Node} node
-   * @param {String} name
-   * @return {String|null}
-   */
-
-  function getBindAttr(node, name) {
-    var val = getAttr(node, ':' + name);
-    if (val === null) {
-      val = getAttr(node, 'v-bind:' + name);
-    }
-    return val;
-  }
-
-  /**
-   * Check the presence of a bind attribute.
-   *
-   * @param {Node} node
-   * @param {String} name
-   * @return {Boolean}
-   */
-
-  function hasBindAttr(node, name) {
-    return node.hasAttribute(name) || node.hasAttribute(':' + name) || node.hasAttribute('v-bind:' + name);
-  }
-
-  /**
-   * Insert el before target
-   *
-   * @param {Element} el
-   * @param {Element} target
-   */
-
-  function before(el, target) {
-    target.parentNode.insertBefore(el, target);
-  }
-
-  /**
-   * Insert el after target
-   *
-   * @param {Element} el
-   * @param {Element} target
-   */
-
-  function after(el, target) {
-    if (target.nextSibling) {
-      before(el, target.nextSibling);
-    } else {
-      target.parentNode.appendChild(el);
-    }
-  }
-
-  /**
-   * Remove el from DOM
-   *
-   * @param {Element} el
-   */
-
-  function remove(el) {
-    el.parentNode.removeChild(el);
-  }
-
-  /**
-   * Prepend el to target
-   *
-   * @param {Element} el
-   * @param {Element} target
-   */
-
-  function prepend(el, target) {
-    if (target.firstChild) {
-      before(el, target.firstChild);
-    } else {
-      target.appendChild(el);
-    }
-  }
-
-  /**
-   * Replace target with el
-   *
-   * @param {Element} target
-   * @param {Element} el
-   */
-
-  function replace(target, el) {
-    var parent = target.parentNode;
-    if (parent) {
-      parent.replaceChild(el, target);
-    }
-  }
-
-  /**
-   * Add event listener shorthand.
-   *
-   * @param {Element} el
-   * @param {String} event
-   * @param {Function} cb
-   * @param {Boolean} [useCapture]
-   */
-
-  function on(el, event, cb, useCapture) {
-    el.addEventListener(event, cb, useCapture);
-  }
-
-  /**
-   * Remove event listener shorthand.
-   *
-   * @param {Element} el
-   * @param {String} event
-   * @param {Function} cb
-   */
-
-  function off(el, event, cb) {
-    el.removeEventListener(event, cb);
-  }
-
-  /**
-   * For IE9 compat: when both class and :class are present
-   * getAttribute('class') returns wrong value...
-   *
-   * @param {Element} el
-   * @return {String}
-   */
-
-  function getClass(el) {
-    var classname = el.className;
-    if (typeof classname === 'object') {
-      classname = classname.baseVal || '';
-    }
-    return classname;
-  }
-
-  /**
-   * In IE9, setAttribute('class') will result in empty class
-   * if the element also has the :class attribute; However in
-   * PhantomJS, setting `className` does not work on SVG elements...
-   * So we have to do a conditional check here.
-   *
-   * @param {Element} el
-   * @param {String} cls
-   */
-
-  function setClass(el, cls) {
-    /* istanbul ignore if */
-    if (isIE9 && !/svg$/.test(el.namespaceURI)) {
-      el.className = cls;
-    } else {
-      el.setAttribute('class', cls);
-    }
-  }
-
-  /**
-   * Add class with compatibility for IE & SVG
-   *
-   * @param {Element} el
-   * @param {String} cls
-   */
-
-  function addClass(el, cls) {
-    if (el.classList) {
-      el.classList.add(cls);
-    } else {
-      var cur = ' ' + getClass(el) + ' ';
-      if (cur.indexOf(' ' + cls + ' ') < 0) {
-        setClass(el, (cur + cls).trim());
-      }
-    }
-  }
-
-  /**
-   * Remove class with compatibility for IE & SVG
-   *
-   * @param {Element} el
-   * @param {String} cls
-   */
-
-  function removeClass(el, cls) {
-    if (el.classList) {
-      el.classList.remove(cls);
-    } else {
-      var cur = ' ' + getClass(el) + ' ';
-      var tar = ' ' + cls + ' ';
-      while (cur.indexOf(tar) >= 0) {
-        cur = cur.replace(tar, ' ');
-      }
-      setClass(el, cur.trim());
-    }
-    if (!el.className) {
-      el.removeAttribute('class');
-    }
-  }
-
-  /**
-   * Extract raw content inside an element into a temporary
-   * container div
-   *
-   * @param {Element} el
-   * @param {Boolean} asFragment
-   * @return {Element|DocumentFragment}
-   */
-
-  function extractContent(el, asFragment) {
-    var child;
-    var rawContent;
-    /* istanbul ignore if */
-    if (isTemplate(el) && isFragment(el.content)) {
-      el = el.content;
-    }
-    if (el.hasChildNodes()) {
-      trimNode(el);
-      rawContent = asFragment ? document.createDocumentFragment() : document.createElement('div');
-      /* eslint-disable no-cond-assign */
-      while (child = el.firstChild) {
-        /* eslint-enable no-cond-assign */
-        rawContent.appendChild(child);
-      }
-    }
-    return rawContent;
-  }
-
-  /**
-   * Trim possible empty head/tail text and comment
-   * nodes inside a parent.
-   *
-   * @param {Node} node
-   */
-
-  function trimNode(node) {
-    var child;
-    /* eslint-disable no-sequences */
-    while ((child = node.firstChild, isTrimmable(child))) {
-      node.removeChild(child);
-    }
-    while ((child = node.lastChild, isTrimmable(child))) {
-      node.removeChild(child);
-    }
-    /* eslint-enable no-sequences */
-  }
-
-  function isTrimmable(node) {
-    return node && (node.nodeType === 3 && !node.data.trim() || node.nodeType === 8);
-  }
-
-  /**
-   * Check if an element is a template tag.
-   * Note if the template appears inside an SVG its tagName
-   * will be in lowercase.
-   *
-   * @param {Element} el
-   */
-
-  function isTemplate(el) {
-    return el.tagName && el.tagName.toLowerCase() === 'template';
-  }
-
-  /**
-   * Create an "anchor" for performing dom insertion/removals.
-   * This is used in a number of scenarios:
-   * - fragment instance
-   * - v-html
-   * - v-if
-   * - v-for
-   * - component
-   *
-   * @param {String} content
-   * @param {Boolean} persist - IE trashes empty textNodes on
-   *                            cloneNode(true), so in certain
-   *                            cases the anchor needs to be
-   *                            non-empty to be persisted in
-   *                            templates.
-   * @return {Comment|Text}
-   */
-
-  function createAnchor(content, persist) {
-    var anchor = config.debug ? document.createComment(content) : document.createTextNode(persist ? ' ' : '');
-    anchor.__v_anchor = true;
-    return anchor;
-  }
-
-  /**
-   * Find a component ref attribute that starts with $.
-   *
-   * @param {Element} node
-   * @return {String|undefined}
-   */
-
-  var refRE = /^v-ref:/;
-
-  function findRef(node) {
-    if (node.hasAttributes()) {
-      var attrs = node.attributes;
-      for (var i = 0, l = attrs.length; i < l; i++) {
-        var name = attrs[i].name;
-        if (refRE.test(name)) {
-          return camelize(name.replace(refRE, ''));
-        }
-      }
-    }
-  }
-
-  /**
-   * Map a function to a range of nodes .
-   *
-   * @param {Node} node
-   * @param {Node} end
-   * @param {Function} op
-   */
-
-  function mapNodeRange(node, end, op) {
-    var next;
-    while (node !== end) {
-      next = node.nextSibling;
-      op(node);
-      node = next;
-    }
-    op(end);
-  }
-
-  /**
-   * Remove a range of nodes with transition, store
-   * the nodes in a fragment with correct ordering,
-   * and call callback when done.
-   *
-   * @param {Node} start
-   * @param {Node} end
-   * @param {Vue} vm
-   * @param {DocumentFragment} frag
-   * @param {Function} cb
-   */
-
-  function removeNodeRange(start, end, vm, frag, cb) {
-    var done = false;
-    var removed = 0;
-    var nodes = [];
-    mapNodeRange(start, end, function (node) {
-      if (node === end) done = true;
-      nodes.push(node);
-      removeWithTransition(node, vm, onRemoved);
-    });
-    function onRemoved() {
-      removed++;
-      if (done && removed >= nodes.length) {
-        for (var i = 0; i < nodes.length; i++) {
-          frag.appendChild(nodes[i]);
-        }
-        cb && cb();
-      }
-    }
-  }
-
-  /**
-   * Check if a node is a DocumentFragment.
-   *
-   * @param {Node} node
-   * @return {Boolean}
-   */
-
-  function isFragment(node) {
-    return node && node.nodeType === 11;
-  }
-
-  /**
-   * Get outerHTML of elements, taking care
-   * of SVG elements in IE as well.
-   *
-   * @param {Element} el
-   * @return {String}
-   */
-
-  function getOuterHTML(el) {
-    if (el.outerHTML) {
-      return el.outerHTML;
-    } else {
-      var container = document.createElement('div');
-      container.appendChild(el.cloneNode(true));
-      return container.innerHTML;
-    }
-  }
-
-  var commonTagRE = /^(div|p|span|img|a|b|i|br|ul|ol|li|h1|h2|h3|h4|h5|h6|code|pre|table|th|td|tr|form|label|input|select|option|nav|article|section|header|footer)$/i;
-  var reservedTagRE = /^(slot|partial|component)$/i;
-
-  var isUnknownElement = undefined;
-  if ('development' !== 'production') {
-    isUnknownElement = function (el, tag) {
-      if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement;
-      } else {
-        return (/HTMLUnknownElement/.test(el.toString()) &&
-          // Chrome returns unknown for several HTML5 elements.
-          // https://code.google.com/p/chromium/issues/detail?id=540526
-          // Firefox returns unknown for some "Interactive elements."
-          !/^(data|time|rtc|rb|details|dialog|summary)$/.test(tag)
-        );
-      }
-    };
-  }
-
-  /**
-   * Check if an element is a component, if yes return its
-   * component id.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Object|undefined}
-   */
-
-  function checkComponentAttr(el, options) {
-    var tag = el.tagName.toLowerCase();
-    var hasAttrs = el.hasAttributes();
-    if (!commonTagRE.test(tag) && !reservedTagRE.test(tag)) {
-      if (resolveAsset(options, 'components', tag)) {
-        return { id: tag };
-      } else {
-        var is = hasAttrs && getIsBinding(el, options);
-        if (is) {
-          return is;
-        } else if ('development' !== 'production') {
-          var expectedTag = options._componentNameMap && options._componentNameMap[tag];
-          if (expectedTag) {
-            warn('Unknown custom element: <' + tag + '> - ' + 'did you mean <' + expectedTag + '>? ' + 'HTML is case-insensitive, remember to use kebab-case in templates.');
-          } else if (isUnknownElement(el, tag)) {
-            warn('Unknown custom element: <' + tag + '> - did you ' + 'register the component correctly? For recursive components, ' + 'make sure to provide the "name" option.');
-          }
-        }
-      }
-    } else if (hasAttrs) {
-      return getIsBinding(el, options);
-    }
-  }
-
-  /**
-   * Get "is" binding from an element.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Object|undefined}
-   */
-
-  function getIsBinding(el, options) {
-    // dynamic syntax
-    var exp = el.getAttribute('is');
-    if (exp != null) {
-      if (resolveAsset(options, 'components', exp)) {
-        el.removeAttribute('is');
-        return { id: exp };
-      }
-    } else {
-      exp = getBindAttr(el, 'is');
-      if (exp != null) {
-        return { id: exp, dynamic: true };
-      }
-    }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   *
-   * All strategy functions follow the same signature:
-   *
-   * @param {*} parentVal
-   * @param {*} childVal
-   * @param {Vue} [vm]
-   */
-
-  var strats = config.optionMergeStrategies = Object.create(null);
-
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-
-  function mergeData(to, from) {
-    var key, toVal, fromVal;
-    for (key in from) {
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (isObject(toVal) && isObject(fromVal)) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to;
-  }
-
-  /**
-   * Data
-   */
-
-  strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal;
-      }
-      if (typeof childVal !== 'function') {
-        'development' !== 'production' && warn('The "data" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);
-        return parentVal;
-      }
-      if (!parentVal) {
-        return childVal;
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn() {
-        return mergeData(childVal.call(this), parentVal.call(this));
-      };
-    } else if (parentVal || childVal) {
-      return function mergedInstanceDataFn() {
-        // instance merge
-        var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal;
-        var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData);
-        } else {
-          return defaultData;
-        }
-      };
-    }
-  };
-
-  /**
-   * El
-   */
-
-  strats.el = function (parentVal, childVal, vm) {
-    if (!vm && childVal && typeof childVal !== 'function') {
-      'development' !== 'production' && warn('The "el" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm);
-      return;
-    }
-    var ret = childVal || parentVal;
-    // invoke the element factory if this is instance merge
-    return vm && typeof ret === 'function' ? ret.call(vm) : ret;
-  };
-
-  /**
-   * Hooks and param attributes are merged as arrays.
-   */
-
-  strats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) {
-    return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal;
-  };
-
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-
-  function mergeAssets(parentVal, childVal) {
-    var res = Object.create(parentVal || null);
-    return childVal ? extend(res, guardArrayAssets(childVal)) : res;
-  }
-
-  config._assetTypes.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-  });
-
-  /**
-   * Events & Watchers.
-   *
-   * Events & watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-
-  strats.watch = strats.events = function (parentVal, childVal) {
-    if (!childVal) return parentVal;
-    if (!parentVal) return childVal;
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key in childVal) {
-      var parent = ret[key];
-      var child = childVal[key];
-      if (parent && !isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key] = parent ? parent.concat(child) : [child];
-    }
-    return ret;
-  };
-
-  /**
-   * Other object hashes.
-   */
-
-  strats.props = strats.methods = strats.computed = function (parentVal, childVal) {
-    if (!childVal) return parentVal;
-    if (!parentVal) return childVal;
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    extend(ret, childVal);
-    return ret;
-  };
-
-  /**
-   * Default strategy.
-   */
-
-  var defaultStrat = function defaultStrat(parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-  };
-
-  /**
-   * Make sure component options get converted to actual
-   * constructors.
-   *
-   * @param {Object} options
-   */
-
-  function guardComponents(options) {
-    if (options.components) {
-      var components = options.components = guardArrayAssets(options.components);
-      var ids = Object.keys(components);
-      var def;
-      if ('development' !== 'production') {
-        var map = options._componentNameMap = {};
-      }
-      for (var i = 0, l = ids.length; i < l; i++) {
-        var key = ids[i];
-        if (commonTagRE.test(key) || reservedTagRE.test(key)) {
-          'development' !== 'production' && warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + key);
-          continue;
-        }
-        // record a all lowercase <-> kebab-case mapping for
-        // possible custom element case error warning
-        if ('development' !== 'production') {
-          map[key.replace(/-/g, '').toLowerCase()] = hyphenate(key);
-        }
-        def = components[key];
-        if (isPlainObject(def)) {
-          components[key] = Vue.extend(def);
-        }
-      }
-    }
-  }
-
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   *
-   * @param {Object} options
-   */
-
-  function guardProps(options) {
-    var props = options.props;
-    var i, val;
-    if (isArray(props)) {
-      options.props = {};
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === 'string') {
-          options.props[val] = null;
-        } else if (val.name) {
-          options.props[val.name] = val;
-        }
-      }
-    } else if (isPlainObject(props)) {
-      var keys = Object.keys(props);
-      i = keys.length;
-      while (i--) {
-        val = props[keys[i]];
-        if (typeof val === 'function') {
-          props[keys[i]] = { type: val };
-        }
-      }
-    }
-  }
-
-  /**
-   * Guard an Array-format assets option and converted it
-   * into the key-value Object format.
-   *
-   * @param {Object|Array} assets
-   * @return {Object}
-   */
-
-  function guardArrayAssets(assets) {
-    if (isArray(assets)) {
-      var res = {};
-      var i = assets.length;
-      var asset;
-      while (i--) {
-        asset = assets[i];
-        var id = typeof asset === 'function' ? asset.options && asset.options.name || asset.id : asset.name || asset.id;
-        if (!id) {
-          'development' !== 'production' && warn('Array-syntax assets must provide a "name" or "id" field.');
-        } else {
-          res[id] = asset;
-        }
-      }
-      return res;
-    }
-    return assets;
-  }
-
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   *
-   * @param {Object} parent
-   * @param {Object} child
-   * @param {Vue} [vm] - if vm is present, indicates this is
-   *                     an instantiation merge.
-   */
-
-  function mergeOptions(parent, child, vm) {
-    guardComponents(child);
-    guardProps(child);
-    if ('development' !== 'production') {
-      if (child.propsData && !vm) {
-        warn('propsData can only be used as an instantiation option.');
-      }
-    }
-    var options = {};
-    var key;
-    if (child['extends']) {
-      parent = typeof child['extends'] === 'function' ? mergeOptions(parent, child['extends'].options, vm) : mergeOptions(parent, child['extends'], vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        var mixin = child.mixins[i];
-        var mixinOptions = mixin.prototype instanceof Vue ? mixin.options : mixin;
-        parent = mergeOptions(parent, mixinOptions, vm);
-      }
-    }
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField(key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-  }
-
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   *
-   * @param {Object} options
-   * @param {String} type
-   * @param {String} id
-   * @param {Boolean} warnMissing
-   * @return {Object|Function}
-   */
-
-  function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-      return;
-    }
-    var assets = options[type];
-    var camelizedId;
-    var res = assets[id] ||
-    // camelCase ID
-    assets[camelizedId = camelize(id)] ||
-    // Pascal Case ID
-    assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)];
-    if ('development' !== 'production' && warnMissing && !res) {
-      warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-  }
-
-  var uid$1 = 0;
-
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   *
-   * @constructor
-   */
-  function Dep() {
-    this.id = uid$1++;
-    this.subs = [];
-  }
-
-  // the current target watcher being evaluated.
-  // this is globally unique because there could be only one
-  // watcher being evaluated at any time.
-  Dep.target = null;
-
-  /**
-   * Add a directive subscriber.
-   *
-   * @param {Directive} sub
-   */
-
-  Dep.prototype.addSub = function (sub) {
-    this.subs.push(sub);
-  };
-
-  /**
-   * Remove a directive subscriber.
-   *
-   * @param {Directive} sub
-   */
-
-  Dep.prototype.removeSub = function (sub) {
-    this.subs.$remove(sub);
-  };
-
-  /**
-   * Add self as a dependency to the target watcher.
-   */
-
-  Dep.prototype.depend = function () {
-    Dep.target.addDep(this);
-  };
-
-  /**
-   * Notify all subscribers of a new value.
-   */
-
-  Dep.prototype.notify = function () {
-    // stablize the subscriber list first
-    var subs = toArray(this.subs);
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
-  };
-
-  var arrayProto = Array.prototype;
-  var arrayMethods = Object.create(arrayProto)
-
-  /**
-   * Intercept mutating methods and emit events
-   */
-
-  ;['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'].forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-      // avoid leaking arguments:
-      // http://jsperf.com/closure-with-arguments
-      var i = arguments.length;
-      var args = new Array(i);
-      while (i--) {
-        args[i] = arguments[i];
-      }
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-          inserted = args;
-          break;
-        case 'unshift':
-          inserted = args;
-          break;
-        case 'splice':
-          inserted = args.slice(2);
-          break;
-      }
-      if (inserted) ob.observeArray(inserted);
-      // notify change
-      ob.dep.notify();
-      return result;
-    });
-  });
-
-  /**
-   * Swap the element at the given index with a new value
-   * and emits corresponding event.
-   *
-   * @param {Number} index
-   * @param {*} val
-   * @return {*} - replaced element
-   */
-
-  def(arrayProto, '$set', function $set(index, val) {
-    if (index >= this.length) {
-      this.length = Number(index) + 1;
-    }
-    return this.splice(index, 1, val)[0];
-  });
-
-  /**
-   * Convenience method to remove the element at given index or target element reference.
-   *
-   * @param {*} item
-   */
-
-  def(arrayProto, '$remove', function $remove(item) {
-    /* istanbul ignore if */
-    if (!this.length) return;
-    var index = indexOf(this, item);
-    if (index > -1) {
-      return this.splice(index, 1);
-    }
-  });
-
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
-  /**
-   * By default, when a reactive property is set, the new value is
-   * also converted to become reactive. However in certain cases, e.g.
-   * v-for scope alias and props, we don't want to force conversion
-   * because the value may be a nested value under a frozen data structure.
-   *
-   * So whenever we want to set a reactive property without forcing
-   * conversion on the new value, we wrap that call inside this function.
-   */
-
-  var shouldConvert = true;
-
-  function withoutConversion(fn) {
-    shouldConvert = false;
-    fn();
-    shouldConvert = true;
-  }
-
-  /**
-   * Observer class that are attached to each observed
-   * object. Once attached, the observer converts target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatches updates.
-   *
-   * @param {Array|Object} value
-   * @constructor
-   */
-
-  function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    def(value, '__ob__', this);
-    if (isArray(value)) {
-      var augment = hasProto ? protoAugment : copyAugment;
-      augment(value, arrayMethods, arrayKeys);
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
-  }
-
-  // Instance methods
-
-  /**
-   * Walk through each property and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   *
-   * @param {Object} obj
-   */
-
-  Observer.prototype.walk = function (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0, l = keys.length; i < l; i++) {
-      this.convert(keys[i], obj[keys[i]]);
-    }
-  };
-
-  /**
-   * Observe a list of Array items.
-   *
-   * @param {Array} items
-   */
-
-  Observer.prototype.observeArray = function (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
-  };
-
-  /**
-   * Convert a property into getter/setter so we can emit
-   * the events when the property is accessed/changed.
-   *
-   * @param {String} key
-   * @param {*} val
-   */
-
-  Observer.prototype.convert = function (key, val) {
-    defineReactive(this.value, key, val);
-  };
-
-  /**
-   * Add an owner vm, so that when $set/$delete mutations
-   * happen we can notify owner vms to proxy the keys and
-   * digest the watchers. This is only called when the object
-   * is observed as an instance's root $data.
-   *
-   * @param {Vue} vm
-   */
-
-  Observer.prototype.addVm = function (vm) {
-    (this.vms || (this.vms = [])).push(vm);
-  };
-
-  /**
-   * Remove an owner vm. This is called when the object is
-   * swapped out as an instance's $data object.
-   *
-   * @param {Vue} vm
-   */
-
-  Observer.prototype.removeVm = function (vm) {
-    this.vms.$remove(vm);
-  };
-
-  // helpers
-
-  /**
-   * Augment an target Object or Array by intercepting
-   * the prototype chain using __proto__
-   *
-   * @param {Object|Array} target
-   * @param {Object} src
-   */
-
-  function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-  }
-
-  /**
-   * Augment an target Object or Array by defining
-   * hidden properties.
-   *
-   * @param {Object|Array} target
-   * @param {Object} proto
-   */
-
-  function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
-  }
-
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   *
-   * @param {*} value
-   * @param {Vue} [vm]
-   * @return {Observer|undefined}
-   * @static
-   */
-
-  function observe(value, vm) {
-    if (!value || typeof value !== 'object') {
-      return;
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (shouldConvert && (isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) {
-      ob = new Observer(value);
-    }
-    if (ob && vm) {
-      ob.addVm(vm);
-    }
-    return ob;
-  }
-
-  /**
-   * Define a reactive property on an Object.
-   *
-   * @param {Object} obj
-   * @param {String} key
-   * @param {*} val
-   */
-
-  function defineReactive(obj, key, val) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return;
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-
-    var childOb = observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter() {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-          }
-          if (isArray(value)) {
-            for (var e, i = 0, l = value.length; i < l; i++) {
-              e = value[i];
-              e && e.__ob__ && e.__ob__.dep.depend();
-            }
-          }
-        }
-        return value;
-      },
-      set: function reactiveSetter(newVal) {
-        var value = getter ? getter.call(obj) : val;
-        if (newVal === value) {
-          return;
-        }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = observe(newVal);
-        dep.notify();
-      }
-    });
-  }
-
-
-
-  var util = Object.freeze({
-    defineReactive: defineReactive,
-    set: set,
-    del: del,
-    hasOwn: hasOwn,
-    isLiteral: isLiteral,
-    isReserved: isReserved,
-    _toString: _toString,
-    toNumber: toNumber,
-    toBoolean: toBoolean,
-    stripQuotes: stripQuotes,
-    camelize: camelize,
-    hyphenate: hyphenate,
-    classify: classify,
-    bind: bind,
-    toArray: toArray,
-    extend: extend,
-    isObject: isObject,
-    isPlainObject: isPlainObject,
-    def: def,
-    debounce: _debounce,
-    indexOf: indexOf,
-    cancellable: cancellable,
-    looseEqual: looseEqual,
-    isArray: isArray,
-    hasProto: hasProto,
-    inBrowser: inBrowser,
-    devtools: devtools,
-    isIE: isIE,
-    isIE9: isIE9,
-    isAndroid: isAndroid,
-    isIos: isIos,
-    iosVersionMatch: iosVersionMatch,
-    iosVersion: iosVersion,
-    hasMutationObserverBug: hasMutationObserverBug,
-    get transitionProp () { return transitionProp; },
-    get transitionEndEvent () { return transitionEndEvent; },
-    get animationProp () { return animationProp; },
-    get animationEndEvent () { return animationEndEvent; },
-    nextTick: nextTick,
-    get _Set () { return _Set; },
-    query: query,
-    inDoc: inDoc,
-    getAttr: getAttr,
-    getBindAttr: getBindAttr,
-    hasBindAttr: hasBindAttr,
-    before: before,
-    after: after,
-    remove: remove,
-    prepend: prepend,
-    replace: replace,
-    on: on,
-    off: off,
-    setClass: setClass,
-    addClass: addClass,
-    removeClass: removeClass,
-    extractContent: extractContent,
-    trimNode: trimNode,
-    isTemplate: isTemplate,
-    createAnchor: createAnchor,
-    findRef: findRef,
-    mapNodeRange: mapNodeRange,
-    removeNodeRange: removeNodeRange,
-    isFragment: isFragment,
-    getOuterHTML: getOuterHTML,
-    mergeOptions: mergeOptions,
-    resolveAsset: resolveAsset,
-    checkComponentAttr: checkComponentAttr,
-    commonTagRE: commonTagRE,
-    reservedTagRE: reservedTagRE,
-    get warn () { return warn; }
-  });
-
-  var uid = 0;
-
-  function initMixin (Vue) {
-    /**
-     * The main init sequence. This is called for every
-     * instance, including ones that are created from extended
-     * constructors.
-     *
-     * @param {Object} options - this options object should be
-     *                           the result of merging class
-     *                           options and the options passed
-     *                           in to the constructor.
-     */
-
-    Vue.prototype._init = function (options) {
-      options = options || {};
-
-      this.$el = null;
-      this.$parent = options.parent;
-      this.$root = this.$parent ? this.$parent.$root : this;
-      this.$children = [];
-      this.$refs = {}; // child vm references
-      this.$els = {}; // element references
-      this._watchers = []; // all watchers as an array
-      this._directives = []; // all directives
-
-      // a uid
-      this._uid = uid++;
-
-      // a flag to avoid this being observed
-      this._isVue = true;
-
-      // events bookkeeping
-      this._events = {}; // registered callbacks
-      this._eventsCount = {}; // for $broadcast optimization
-
-      // fragment instance properties
-      this._isFragment = false;
-      this._fragment = // @type {DocumentFragment}
-      this._fragmentStart = // @type {Text|Comment}
-      this._fragmentEnd = null; // @type {Text|Comment}
-
-      // lifecycle state
-      this._isCompiled = this._isDestroyed = this._isReady = this._isAttached = this._isBeingDestroyed = this._vForRemoving = false;
-      this._unlinkFn = null;
-
-      // context:
-      // if this is a transcluded component, context
-      // will be the common parent vm of this instance
-      // and its host.
-      this._context = options._context || this.$parent;
-
-      // scope:
-      // if this is inside an inline v-for, the scope
-      // will be the intermediate scope created for this
-      // repeat fragment. this is used for linking props
-      // and container directives.
-      this._scope = options._scope;
-
-      // fragment:
-      // if this instance is compiled inside a Fragment, it
-      // needs to reigster itself as a child of that fragment
-      // for attach/detach to work properly.
-      this._frag = options._frag;
-      if (this._frag) {
-        this._frag.children.push(this);
-      }
-
-      // push self into parent / transclusion host
-      if (this.$parent) {
-        this.$parent.$children.push(this);
-      }
-
-      // merge options.
-      options = this.$options = mergeOptions(this.constructor.options, options, this);
-
-      // set ref
-      this._updateRef();
-
-      // initialize data as empty object.
-      // it will be filled up in _initData().
-      this._data = {};
-
-      // call init hook
-      this._callHook('init');
-
-      // initialize data observation and scope inheritance.
-      this._initState();
-
-      // setup event system and option events.
-      this._initEvents();
-
-      // call created hook
-      this._callHook('created');
-
-      // if `el` option is passed, start compilation.
-      if (options.el) {
-        this.$mount(options.el);
-      }
-    };
-  }
-
-  var pathCache = new Cache(1000);
-
-  // actions
-  var APPEND = 0;
-  var PUSH = 1;
-  var INC_SUB_PATH_DEPTH = 2;
-  var PUSH_SUB_PATH = 3;
-
-  // states
-  var BEFORE_PATH = 0;
-  var IN_PATH = 1;
-  var BEFORE_IDENT = 2;
-  var IN_IDENT = 3;
-  var IN_SUB_PATH = 4;
-  var IN_SINGLE_QUOTE = 5;
-  var IN_DOUBLE_QUOTE = 6;
-  var AFTER_PATH = 7;
-  var ERROR = 8;
-
-  var pathStateMachine = [];
-
-  pathStateMachine[BEFORE_PATH] = {
-    'ws': [BEFORE_PATH],
-    'ident': [IN_IDENT, APPEND],
-    '[': [IN_SUB_PATH],
-    'eof': [AFTER_PATH]
-  };
-
-  pathStateMachine[IN_PATH] = {
-    'ws': [IN_PATH],
-    '.': [BEFORE_IDENT],
-    '[': [IN_SUB_PATH],
-    'eof': [AFTER_PATH]
-  };
-
-  pathStateMachine[BEFORE_IDENT] = {
-    'ws': [BEFORE_IDENT],
-    'ident': [IN_IDENT, APPEND]
-  };
-
-  pathStateMachine[IN_IDENT] = {
-    'ident': [IN_IDENT, APPEND],
-    '0': [IN_IDENT, APPEND],
-    'number': [IN_IDENT, APPEND],
-    'ws': [IN_PATH, PUSH],
-    '.': [BEFORE_IDENT, PUSH],
-    '[': [IN_SUB_PATH, PUSH],
-    'eof': [AFTER_PATH, PUSH]
-  };
-
-  pathStateMachine[IN_SUB_PATH] = {
-    "'": [IN_SINGLE_QUOTE, APPEND],
-    '"': [IN_DOUBLE_QUOTE, APPEND],
-    '[': [IN_SUB_PATH, INC_SUB_PATH_DEPTH],
-    ']': [IN_PATH, PUSH_SUB_PATH],
-    'eof': ERROR,
-    'else': [IN_SUB_PATH, APPEND]
-  };
-
-  pathStateMachine[IN_SINGLE_QUOTE] = {
-    "'": [IN_SUB_PATH, APPEND],
-    'eof': ERROR,
-    'else': [IN_SINGLE_QUOTE, APPEND]
-  };
-
-  pathStateMachine[IN_DOUBLE_QUOTE] = {
-    '"': [IN_SUB_PATH, APPEND],
-    'eof': ERROR,
-    'else': [IN_DOUBLE_QUOTE, APPEND]
-  };
-
-  /**
-   * Determine the type of a character in a keypath.
-   *
-   * @param {Char} ch
-   * @return {String} type
-   */
-
-  function getPathCharType(ch) {
-    if (ch === undefined) {
-      return 'eof';
-    }
-
-    var code = ch.charCodeAt(0);
-
-    switch (code) {
-      case 0x5B: // [
-      case 0x5D: // ]
-      case 0x2E: // .
-      case 0x22: // "
-      case 0x27: // '
-      case 0x30:
-        // 0
-        return ch;
-
-      case 0x5F: // _
-      case 0x24:
-        // $
-        return 'ident';
-
-      case 0x20: // Space
-      case 0x09: // Tab
-      case 0x0A: // Newline
-      case 0x0D: // Return
-      case 0xA0: // No-break space
-      case 0xFEFF: // Byte Order Mark
-      case 0x2028: // Line Separator
-      case 0x2029:
-        // Paragraph Separator
-        return 'ws';
-    }
-
-    // a-z, A-Z
-    if (code >= 0x61 && code <= 0x7A || code >= 0x41 && code <= 0x5A) {
-      return 'ident';
-    }
-
-    // 1-9
-    if (code >= 0x31 && code <= 0x39) {
-      return 'number';
-    }
-
-    return 'else';
-  }
-
-  /**
-   * Format a subPath, return its plain form if it is
-   * a literal string or number. Otherwise prepend the
-   * dynamic indicator (*).
-   *
-   * @param {String} path
-   * @return {String}
-   */
-
-  function formatSubPath(path) {
-    var trimmed = path.trim();
-    // invalid leading 0
-    if (path.charAt(0) === '0' && isNaN(path)) {
-      return false;
-    }
-    return isLiteral(trimmed) ? stripQuotes(trimmed) : '*' + trimmed;
-  }
-
-  /**
-   * Parse a string path into an array of segments
-   *
-   * @param {String} path
-   * @return {Array|undefined}
-   */
-
-  function parse(path) {
-    var keys = [];
-    var index = -1;
-    var mode = BEFORE_PATH;
-    var subPathDepth = 0;
-    var c, newChar, key, type, transition, action, typeMap;
-
-    var actions = [];
-
-    actions[PUSH] = function () {
-      if (key !== undefined) {
-        keys.push(key);
-        key = undefined;
-      }
-    };
-
-    actions[APPEND] = function () {
-      if (key === undefined) {
-        key = newChar;
-      } else {
-        key += newChar;
-      }
-    };
-
-    actions[INC_SUB_PATH_DEPTH] = function () {
-      actions[APPEND]();
-      subPathDepth++;
-    };
-
-    actions[PUSH_SUB_PATH] = function () {
-      if (subPathDepth > 0) {
-        subPathDepth--;
-        mode = IN_SUB_PATH;
-        actions[APPEND]();
-      } else {
-        subPathDepth = 0;
-        key = formatSubPath(key);
-        if (key === false) {
-          return false;
-        } else {
-          actions[PUSH]();
-        }
-      }
-    };
-
-    function maybeUnescapeQuote() {
-      var nextChar = path[index + 1];
-      if (mode === IN_SINGLE_QUOTE && nextChar === "'" || mode === IN_DOUBLE_QUOTE && nextChar === '"') {
-        index++;
-        newChar = '\\' + nextChar;
-        actions[APPEND]();
-        return true;
-      }
-    }
-
-    while (mode != null) {
-      index++;
-      c = path[index];
-
-      if (c === '\\' && maybeUnescapeQuote()) {
-        continue;
-      }
-
-      type = getPathCharType(c);
-      typeMap = pathStateMachine[mode];
-      transition = typeMap[type] || typeMap['else'] || ERROR;
-
-      if (transition === ERROR) {
-        return; // parse error
-      }
-
-      mode = transition[0];
-      action = actions[transition[1]];
-      if (action) {
-        newChar = transition[2];
-        newChar = newChar === undefined ? c : newChar;
-        if (action() === false) {
-          return;
-        }
-      }
-
-      if (mode === AFTER_PATH) {
-        keys.raw = path;
-        return keys;
-      }
-    }
-  }
-
-  /**
-   * External parse that check for a cache hit first
-   *
-   * @param {String} path
-   * @return {Array|undefined}
-   */
-
-  function parsePath(path) {
-    var hit = pathCache.get(path);
-    if (!hit) {
-      hit = parse(path);
-      if (hit) {
-        pathCache.put(path, hit);
-      }
-    }
-    return hit;
-  }
-
-  /**
-   * Get from an object from a path string
-   *
-   * @param {Object} obj
-   * @param {String} path
-   */
-
-  function getPath(obj, path) {
-    return parseExpression(path).get(obj);
-  }
-
-  /**
-   * Warn against setting non-existent root path on a vm.
-   */
-
-  var warnNonExistent;
-  if ('development' !== 'production') {
-    warnNonExistent = function (path, vm) {
-      warn('You are setting a non-existent path "' + path.raw + '" ' + 'on a vm instance. Consider pre-initializing the property ' + 'with the "data" option for more reliable reactivity ' + 'and better performance.', vm);
-    };
-  }
-
-  /**
-   * Set on an object from a path
-   *
-   * @param {Object} obj
-   * @param {String | Array} path
-   * @param {*} val
-   */
-
-  function setPath(obj, path, val) {
-    var original = obj;
-    if (typeof path === 'string') {
-      path = parse(path);
-    }
-    if (!path || !isObject(obj)) {
-      return false;
-    }
-    var last, key;
-    for (var i = 0, l = path.length; i < l; i++) {
-      last = obj;
-      key = path[i];
-      if (key.charAt(0) === '*') {
-        key = parseExpression(key.slice(1)).get.call(original, original);
-      }
-      if (i < l - 1) {
-        obj = obj[key];
-        if (!isObject(obj)) {
-          obj = {};
-          if ('development' !== 'production' && last._isVue) {
-            warnNonExistent(path, last);
-          }
-          set(last, key, obj);
-        }
-      } else {
-        if (isArray(obj)) {
-          obj.$set(key, val);
-        } else if (key in obj) {
-          obj[key] = val;
-        } else {
-          if ('development' !== 'production' && obj._isVue) {
-            warnNonExistent(path, obj);
-          }
-          set(obj, key, val);
-        }
-      }
-    }
-    return true;
-  }
-
-var path = Object.freeze({
-    parsePath: parsePath,
-    getPath: getPath,
-    setPath: setPath
-  });
-
-  var expressionCache = new Cache(1000);
-
-  var allowedKeywords = 'Math,Date,this,true,false,null,undefined,Infinity,NaN,' + 'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' + 'encodeURIComponent,parseInt,parseFloat';
-  var allowedKeywordsRE = new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)');
-
-  // keywords that don't make sense inside expressions
-  var improperKeywords = 'break,case,class,catch,const,continue,debugger,default,' + 'delete,do,else,export,extends,finally,for,function,if,' + 'import,in,instanceof,let,return,super,switch,throw,try,' + 'var,while,with,yield,enum,await,implements,package,' + 'protected,static,interface,private,public';
-  var improperKeywordsRE = new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)');
-
-  var wsRE = /\s/g;
-  var newlineRE = /\n/g;
-  var saveRE = /[\{,]\s*[\w\$_]+\s*:|('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`)|new |typeof |void /g;
-  var restoreRE = /"(\d+)"/g;
-  var pathTestRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/;
-  var identRE = /[^\w$\.](?:[A-Za-z_$][\w$]*)/g;
-  var literalValueRE$1 = /^(?:true|false|null|undefined|Infinity|NaN)$/;
-
-  function noop() {}
-
-  /**
-   * Save / Rewrite / Restore
-   *
-   * When rewriting paths found in an expression, it is
-   * possible for the same letter sequences to be found in
-   * strings and Object literal property keys. Therefore we
-   * remove and store these parts in a temporary array, and
-   * restore them after the path rewrite.
-   */
-
-  var saved = [];
-
-  /**
-   * Save replacer
-   *
-   * The save regex can match two possible cases:
-   * 1. An opening object literal
-   * 2. A string
-   * If matched as a plain string, we need to escape its
-   * newlines, since the string needs to be preserved when
-   * generating the function body.
-   *
-   * @param {String} str
-   * @param {String} isString - str if matched as a string
-   * @return {String} - placeholder with index
-   */
-
-  function save(str, isString) {
-    var i = saved.length;
-    saved[i] = isString ? str.replace(newlineRE, '\\n') : str;
-    return '"' + i + '"';
-  }
-
-  /**
-   * Path rewrite replacer
-   *
-   * @param {String} raw
-   * @return {String}
-   */
-
-  function rewrite(raw) {
-    var c = raw.charAt(0);
-    var path = raw.slice(1);
-    if (allowedKeywordsRE.test(path)) {
-      return raw;
-    } else {
-      path = path.indexOf('"') > -1 ? path.replace(restoreRE, restore) : path;
-      return c + 'scope.' + path;
-    }
-  }
-
-  /**
-   * Restore replacer
-   *
-   * @param {String} str
-   * @param {String} i - matched save index
-   * @return {String}
-   */
-
-  function restore(str, i) {
-    return saved[i];
-  }
-
-  /**
-   * Rewrite an expression, prefixing all path accessors with
-   * `scope.` and generate getter/setter functions.
-   *
-   * @param {String} exp
-   * @return {Function}
-   */
-
-  function compileGetter(exp) {
-    if (improperKeywordsRE.test(exp)) {
-      'development' !== 'production' && warn('Avoid using reserved keywords in expression: ' + exp);
-    }
-    // reset state
-    saved.length = 0;
-    // save strings and object literal keys
-    var body = exp.replace(saveRE, save).replace(wsRE, '');
-    // rewrite all paths
-    // pad 1 space here because the regex matches 1 extra char
-    body = (' ' + body).replace(identRE, rewrite).replace(restoreRE, restore);
-    return makeGetterFn(body);
-  }
-
-  /**
-   * Build a getter function. Requires eval.
-   *
-   * We isolate the try/catch so it doesn't affect the
-   * optimization of the parse function when it is not called.
-   *
-   * @param {String} body
-   * @return {Function|undefined}
-   */
-
-  function makeGetterFn(body) {
-    try {
-      /* eslint-disable no-new-func */
-      return new Function('scope', 'return ' + body + ';');
-      /* eslint-enable no-new-func */
-    } catch (e) {
-      if ('development' !== 'production') {
-        /* istanbul ignore if */
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn('It seems you are using the default build of Vue.js in an environment ' + 'with Content Security Policy that prohibits unsafe-eval. ' + 'Use the CSP-compliant build instead: ' + 'http://vuejs.org/guide/installation.html#CSP-compliant-build');
-        } else {
-          warn('Invalid expression. ' + 'Generated function body: ' + body);
-        }
-      }
-      return noop;
-    }
-  }
-
-  /**
-   * Compile a setter function for the expression.
-   *
-   * @param {String} exp
-   * @return {Function|undefined}
-   */
-
-  function compileSetter(exp) {
-    var path = parsePath(exp);
-    if (path) {
-      return function (scope, val) {
-        setPath(scope, path, val);
-      };
-    } else {
-      'development' !== 'production' && warn('Invalid setter expression: ' + exp);
-    }
-  }
-
-  /**
-   * Parse an expression into re-written getter/setters.
-   *
-   * @param {String} exp
-   * @param {Boolean} needSet
-   * @return {Function}
-   */
-
-  function parseExpression(exp, needSet) {
-    exp = exp.trim();
-    // try cache
-    var hit = expressionCache.get(exp);
-    if (hit) {
-      if (needSet && !hit.set) {
-        hit.set = compileSetter(hit.exp);
-      }
-      return hit;
-    }
-    var res = { exp: exp };
-    res.get = isSimplePath(exp) && exp.indexOf('[') < 0
-    // optimized super simple getter
-    ? makeGetterFn('scope.' + exp)
-    // dynamic getter
-    : compileGetter(exp);
-    if (needSet) {
-      res.set = compileSetter(exp);
-    }
-    expressionCache.put(exp, res);
-    return res;
-  }
-
-  /**
-   * Check if an expression is a simple path.
-   *
-   * @param {String} exp
-   * @return {Boolean}
-   */
-
-  function isSimplePath(exp) {
-    return pathTestRE.test(exp) &&
-    // don't treat literal values as paths
-    !literalValueRE$1.test(exp) &&
-    // Math constants e.g. Math.PI, Math.E etc.
-    exp.slice(0, 5) !== 'Math.';
-  }
-
-var expression = Object.freeze({
-    parseExpression: parseExpression,
-    isSimplePath: isSimplePath
-  });
-
-  // we have two separate queues: one for directive updates
-  // and one for user watcher registered via $watch().
-  // we want to guarantee directive updates to be called
-  // before user watchers so that when user watchers are
-  // triggered, the DOM would have already been in updated
-  // state.
-
-  var queue = [];
-  var userQueue = [];
-  var has = {};
-  var circular = {};
-  var waiting = false;
-
-  /**
-   * Reset the batcher's state.
-   */
-
-  function resetBatcherState() {
-    queue.length = 0;
-    userQueue.length = 0;
-    has = {};
-    circular = {};
-    waiting = false;
-  }
-
-  /**
-   * Flush both queues and run the watchers.
-   */
-
-  function flushBatcherQueue() {
-    var _again = true;
-
-    _function: while (_again) {
-      _again = false;
-
-      runBatcherQueue(queue);
-      runBatcherQueue(userQueue);
-      // user watchers triggered more watchers,
-      // keep flushing until it depletes
-      if (queue.length) {
-        _again = true;
-        continue _function;
-      }
-      // dev tool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-        devtools.emit('flush');
-      }
-      resetBatcherState();
-    }
-  }
-
-  /**
-   * Run the watchers in a single queue.
-   *
-   * @param {Array} queue
-   */
-
-  function runBatcherQueue(queue) {
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (var i = 0; i < queue.length; i++) {
-      var watcher = queue[i];
-      var id = watcher.id;
-      has[id] = null;
-      watcher.run();
-      // in dev build, check and stop circular updates.
-      if ('development' !== 'production' && has[id] != null) {
-        circular[id] = (circular[id] || 0) + 1;
-        if (circular[id] > config._maxUpdateCount) {
-          warn('You may have an infinite update loop for watcher ' + 'with expression "' + watcher.expression + '"', watcher.vm);
-          break;
-        }
-      }
-    }
-    queue.length = 0;
-  }
-
-  /**
-   * Push a watcher into the watcher queue.
-   * Jobs with duplicate IDs will be skipped unless it's
-   * pushed when the queue is being flushed.
-   *
-   * @param {Watcher} watcher
-   *   properties:
-   *   - {Number} id
-   *   - {Function} run
-   */
-
-  function pushWatcher(watcher) {
-    var id = watcher.id;
-    if (has[id] == null) {
-      // push watcher into appropriate queue
-      var q = watcher.user ? userQueue : queue;
-      has[id] = q.length;
-      q.push(watcher);
-      // queue the flush
-      if (!waiting) {
-        waiting = true;
-        nextTick(flushBatcherQueue);
-      }
-    }
-  }
-
-  var uid$2 = 0;
-
-  /**
-   * A watcher parses an expression, collects dependencies,
-   * and fires callback when the expression value changes.
-   * This is used for both the $watch() api and directives.
-   *
-   * @param {Vue} vm
-   * @param {String|Function} expOrFn
-   * @param {Function} cb
-   * @param {Object} options
-   *                 - {Array} filters
-   *                 - {Boolean} twoWay
-   *                 - {Boolean} deep
-   *                 - {Boolean} user
-   *                 - {Boolean} sync
-   *                 - {Boolean} lazy
-   *                 - {Function} [preProcess]
-   *                 - {Function} [postProcess]
-   * @constructor
-   */
-  function Watcher(vm, expOrFn, cb, options) {
-    // mix in options
-    if (options) {
-      extend(this, options);
-    }
-    var isFn = typeof expOrFn === 'function';
-    this.vm = vm;
-    vm._watchers.push(this);
-    this.expression = expOrFn;
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.prevError = null; // for async error stacks
-    // parse expression for getter/setter
-    if (isFn) {
-      this.getter = expOrFn;
-      this.setter = undefined;
-    } else {
-      var res = parseExpression(expOrFn, this.twoWay);
-      this.getter = res.get;
-      this.setter = res.set;
-    }
-    this.value = this.lazy ? undefined : this.get();
-    // state for avoiding false triggers for deep and Array
-    // watchers during vm._digest()
-    this.queued = this.shallow = false;
-  }
-
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-
-  Watcher.prototype.get = function () {
-    this.beforeGet();
-    var scope = this.scope || this.vm;
-    var value;
-    try {
-      value = this.getter.call(scope, scope);
-    } catch (e) {
-      if ('development' !== 'production' && config.warnExpressionErrors) {
-        warn('Error when evaluating expression ' + '"' + this.expression + '": ' + e.toString(), this.vm);
-      }
-    }
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
-    }
-    if (this.preProcess) {
-      value = this.preProcess(value);
-    }
-    if (this.filters) {
-      value = scope._applyFilters(value, null, this.filters, false);
-    }
-    if (this.postProcess) {
-      value = this.postProcess(value);
-    }
-    this.afterGet();
-    return value;
-  };
-
-  /**
-   * Set the corresponding value with the setter.
-   *
-   * @param {*} value
-   */
-
-  Watcher.prototype.set = function (value) {
-    var scope = this.scope || this.vm;
-    if (this.filters) {
-      value = scope._applyFilters(value, this.value, this.filters, true);
-    }
-    try {
-      this.setter.call(scope, scope, value);
-    } catch (e) {
-      if ('development' !== 'production' && config.warnExpressionErrors) {
-        warn('Error when evaluating setter ' + '"' + this.expression + '": ' + e.toString(), this.vm);
-      }
-    }
-    // two-way sync for v-for alias
-    var forContext = scope.$forContext;
-    if (forContext && forContext.alias === this.expression) {
-      if (forContext.filters) {
-        'development' !== 'production' && warn('It seems you are using two-way binding on ' + 'a v-for alias (' + this.expression + '), and the ' + 'v-for has filters. This will not work properly. ' + 'Either remove the filters or use an array of ' + 'objects and bind to object properties instead.', this.vm);
-        return;
-      }
-      forContext._withLock(function () {
-        if (scope.$key) {
-          // original is an object
-          forContext.rawValue[scope.$key] = value;
-        } else {
-          forContext.rawValue.$set(scope.$index, value);
-        }
-      });
-    }
-  };
-
-  /**
-   * Prepare for dependency collection.
-   */
-
-  Watcher.prototype.beforeGet = function () {
-    Dep.target = this;
-  };
-
-  /**
-   * Add a dependency to this directive.
-   *
-   * @param {Dep} dep
-   */
-
-  Watcher.prototype.addDep = function (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id);
-      this.newDeps.push(dep);
-      if (!this.depIds.has(id)) {
-        dep.addSub(this);
-      }
-    }
-  };
-
-  /**
-   * Clean up for dependency collection.
-   */
-
-  Watcher.prototype.afterGet = function () {
-    Dep.target = null;
-    var i = this.deps.length;
-    while (i--) {
-      var dep = this.deps[i];
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this);
-      }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-  };
-
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   *
-   * @param {Boolean} shallow
-   */
-
-  Watcher.prototype.update = function (shallow) {
-    if (this.lazy) {
-      this.dirty = true;
-    } else if (this.sync || !config.async) {
-      this.run();
-    } else {
-      // if queued, only overwrite shallow with non-shallow,
-      // but not the other way around.
-      this.shallow = this.queued ? shallow ? this.shallow : false : !!shallow;
-      this.queued = true;
-      // record before-push error stack in debug mode
-      /* istanbul ignore if */
-      if ('development' !== 'production' && config.debug) {
-        this.prevError = new Error('[vue] async stack trace');
-      }
-      pushWatcher(this);
-    }
-  };
-
-  /**
-   * Batcher job interface.
-   * Will be called by the batcher.
-   */
-
-  Watcher.prototype.run = function () {
-    if (this.active) {
-      var value = this.get();
-      if (value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated; but only do so if this is a
-      // non-shallow update (caused by a vm digest).
-      (isObject(value) || this.deep) && !this.shallow) {
-        // set new value
-        var oldValue = this.value;
-        this.value = value;
-        // in debug + async mode, when a watcher callbacks
-        // throws, we also throw the saved before-push error
-        // so the full cross-tick stack trace is available.
-        var prevError = this.prevError;
-        /* istanbul ignore if */
-        if ('development' !== 'production' && config.debug && prevError) {
-          this.prevError = null;
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            nextTick(function () {
-              throw prevError;
-            }, 0);
-            throw e;
-          }
-        } else {
-          this.cb.call(this.vm, value, oldValue);
-        }
-      }
-      this.queued = this.shallow = false;
-    }
-  };
-
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-
-  Watcher.prototype.evaluate = function () {
-    // avoid overwriting another watcher that is being
-    // collected.
-    var current = Dep.target;
-    this.value = this.get();
-    this.dirty = false;
-    Dep.target = current;
-  };
-
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-
-  Watcher.prototype.depend = function () {
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].depend();
-    }
-  };
-
-  /**
-   * Remove self from all dependencies' subcriber list.
-   */
-
-  Watcher.prototype.teardown = function () {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed or is performing a v-for
-      // re-render (the watcher list is then filtered by v-for).
-      if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) {
-        this.vm._watchers.$remove(this);
-      }
-      var i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
-      }
-      this.active = false;
-      this.vm = this.cb = this.value = null;
-    }
-  };
-
-  /**
-   * Recrusively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   *
-   * @param {*} val
-   */
-
-  var seenObjects = new _Set();
-  function traverse(val, seen) {
-    var i = undefined,
-        keys = undefined;
-    if (!seen) {
-      seen = seenObjects;
-      seen.clear();
-    }
-    var isA = isArray(val);
-    var isO = isObject(val);
-    if ((isA || isO) && Object.isExtensible(val)) {
-      if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-          return;
-        } else {
-          seen.add(depId);
-        }
-      }
-      if (isA) {
-        i = val.length;
-        while (i--) traverse(val[i], seen);
-      } else if (isO) {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--) traverse(val[keys[i]], seen);
-      }
-    }
-  }
-
-  var text$1 = {
-
-    bind: function bind() {
-      this.attr = this.el.nodeType === 3 ? 'data' : 'textContent';
-    },
-
-    update: function update(value) {
-      this.el[this.attr] = _toString(value);
-    }
-  };
-
-  var templateCache = new Cache(1000);
-  var idSelectorCache = new Cache(1000);
-
-  var map = {
-    efault: [0, '', ''],
-    legend: [1, '<fieldset>', '</fieldset>'],
-    tr: [2, '<table><tbody>', '</tbody></table>'],
-    col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>']
-  };
-
-  map.td = map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
-
-  map.option = map.optgroup = [1, '<select multiple="multiple">', '</select>'];
-
-  map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, '<table>', '</table>'];
-
-  map.g = map.defs = map.symbol = map.use = map.image = map.text = map.circle = map.ellipse = map.line = map.path = map.polygon = map.polyline = map.rect = [1, '<svg ' + 'xmlns="http://www.w3.org/2000/svg" ' + 'xmlns:xlink="http://www.w3.org/1999/xlink" ' + 'xmlns:ev="http://www.w3.org/2001/xml-events"' + 'version="1.1">', '</svg>'];
-
-  /**
-   * Check if a node is a supported template node with a
-   * DocumentFragment content.
-   *
-   * @param {Node} node
-   * @return {Boolean}
-   */
-
-  function isRealTemplate(node) {
-    return isTemplate(node) && isFragment(node.content);
-  }
-
-  var tagRE$1 = /<([\w:-]+)/;
-  var entityRE = /&#?\w+?;/;
-  var commentRE = /<!--/;
-
-  /**
-   * Convert a string template to a DocumentFragment.
-   * Determines correct wrapping by tag types. Wrapping
-   * strategy found in jQuery & component/domify.
-   *
-   * @param {String} templateString
-   * @param {Boolean} raw
-   * @return {DocumentFragment}
-   */
-
-  function stringToFragment(templateString, raw) {
-    // try a cache hit first
-    var cacheKey = raw ? templateString : templateString.trim();
-    var hit = templateCache.get(cacheKey);
-    if (hit) {
-      return hit;
-    }
-
-    var frag = document.createDocumentFragment();
-    var tagMatch = templateString.match(tagRE$1);
-    var entityMatch = entityRE.test(templateString);
-    var commentMatch = commentRE.test(templateString);
-
-    if (!tagMatch && !entityMatch && !commentMatch) {
-      // text only, return a single text node.
-      frag.appendChild(document.createTextNode(templateString));
-    } else {
-      var tag = tagMatch && tagMatch[1];
-      var wrap = map[tag] || map.efault;
-      var depth = wrap[0];
-      var prefix = wrap[1];
-      var suffix = wrap[2];
-      var node = document.createElement('div');
-
-      node.innerHTML = prefix + templateString + suffix;
-      while (depth--) {
-        node = node.lastChild;
-      }
-
-      var child;
-      /* eslint-disable no-cond-assign */
-      while (child = node.firstChild) {
-        /* eslint-enable no-cond-assign */
-        frag.appendChild(child);
-      }
-    }
-    if (!raw) {
-      trimNode(frag);
-    }
-    templateCache.put(cacheKey, frag);
-    return frag;
-  }
-
-  /**
-   * Convert a template node to a DocumentFragment.
-   *
-   * @param {Node} node
-   * @return {DocumentFragment}
-   */
-
-  function nodeToFragment(node) {
-    // if its a template tag and the browser supports it,
-    // its content is already a document fragment. However, iOS Safari has
-    // bug when using directly cloned template content with touch
-    // events and can cause crashes when the nodes are removed from DOM, so we
-    // have to treat template elements as string templates. (#2805)
-    /* istanbul ignore if */
-    if (isRealTemplate(node)) {
-      return stringToFragment(node.innerHTML);
-    }
-    // script template
-    if (node.tagName === 'SCRIPT') {
-      return stringToFragment(node.textContent);
-    }
-    // normal node, clone it to avoid mutating the original
-    var clonedNode = cloneNode(node);
-    var frag = document.createDocumentFragment();
-    var child;
-    /* eslint-disable no-cond-assign */
-    while (child = clonedNode.firstChild) {
-      /* eslint-enable no-cond-assign */
-      frag.appendChild(child);
-    }
-    trimNode(frag);
-    return frag;
-  }
-
-  // Test for the presence of the Safari template cloning bug
-  // https://bugs.webkit.org/showug.cgi?id=137755
-  var hasBrokenTemplate = (function () {
-    /* istanbul ignore else */
-    if (inBrowser) {
-      var a = document.createElement('div');
-      a.innerHTML = '<template>1</template>';
-      return !a.cloneNode(true).firstChild.innerHTML;
-    } else {
-      return false;
-    }
-  })();
-
-  // Test for IE10/11 textarea placeholder clone bug
-  var hasTextareaCloneBug = (function () {
-    /* istanbul ignore else */
-    if (inBrowser) {
-      var t = document.createElement('textarea');
-      t.placeholder = 't';
-      return t.cloneNode(true).value === 't';
-    } else {
-      return false;
-    }
-  })();
-
-  /**
-   * 1. Deal with Safari cloning nested <template> bug by
-   *    manually cloning all template instances.
-   * 2. Deal with IE10/11 textarea placeholder bug by setting
-   *    the correct value after cloning.
-   *
-   * @param {Element|DocumentFragment} node
-   * @return {Element|DocumentFragment}
-   */
-
-  function cloneNode(node) {
-    /* istanbul ignore if */
-    if (!node.querySelectorAll) {
-      return node.cloneNode();
-    }
-    var res = node.cloneNode(true);
-    var i, original, cloned;
-    /* istanbul ignore if */
-    if (hasBrokenTemplate) {
-      var tempClone = res;
-      if (isRealTemplate(node)) {
-        node = node.content;
-        tempClone = res.content;
-      }
-      original = node.querySelectorAll('template');
-      if (original.length) {
-        cloned = tempClone.querySelectorAll('template');
-        i = cloned.length;
-        while (i--) {
-          cloned[i].parentNode.replaceChild(cloneNode(original[i]), cloned[i]);
-        }
-      }
-    }
-    /* istanbul ignore if */
-    if (hasTextareaCloneBug) {
-      if (node.tagName === 'TEXTAREA') {
-        res.value = node.value;
-      } else {
-        original = node.querySelectorAll('textarea');
-        if (original.length) {
-          cloned = res.querySelectorAll('textarea');
-          i = cloned.length;
-          while (i--) {
-            cloned[i].value = original[i].value;
-          }
-        }
-      }
-    }
-    return res;
-  }
-
-  /**
-   * Process the template option and normalizes it into a
-   * a DocumentFragment that can be used as a partial or a
-   * instance template.
-   *
-   * @param {*} template
-   *        Possible values include:
-   *        - DocumentFragment object
-   *        - Node object of type Template
-   *        - id selector: '#some-template-id'
-   *        - template string: '<div><span>{{msg}}</span></div>'
-   * @param {Boolean} shouldClone
-   * @param {Boolean} raw
-   *        inline HTML interpolation. Do not check for id
-   *        selector and keep whitespace in the string.
-   * @return {DocumentFragment|undefined}
-   */
-
-  function parseTemplate(template, shouldClone, raw) {
-    var node, frag;
-
-    // if the template is already a document fragment,
-    // do nothing
-    if (isFragment(template)) {
-      trimNode(template);
-      return shouldClone ? cloneNode(template) : template;
-    }
-
-    if (typeof template === 'string') {
-      // id selector
-      if (!raw && template.charAt(0) === '#') {
-        // id selector can be cached too
-        frag = idSelectorCache.get(template);
-        if (!frag) {
-          node = document.getElementById(template.slice(1));
-          if (node) {
-            frag = nodeToFragment(node);
-            // save selector to cache
-            idSelectorCache.put(template, frag);
-          }
-        }
-      } else {
-        // normal string template
-        frag = stringToFragment(template, raw);
-      }
-    } else if (template.nodeType) {
-      // a direct node
-      frag = nodeToFragment(template);
-    }
-
-    return frag && shouldClone ? cloneNode(frag) : frag;
-  }
-
-var template = Object.freeze({
-    cloneNode: cloneNode,
-    parseTemplate: parseTemplate
-  });
-
-  var html = {
-
-    bind: function bind() {
-      // a comment node means this is a binding for
-      // {{{ inline unescaped html }}}
-      if (this.el.nodeType === 8) {
-        // hold nodes
-        this.nodes = [];
-        // replace the placeholder with proper anchor
-        this.anchor = createAnchor('v-html');
-        replace(this.el, this.anchor);
-      }
-    },
-
-    update: function update(value) {
-      value = _toString(value);
-      if (this.nodes) {
-        this.swap(value);
-      } else {
-        this.el.innerHTML = value;
-      }
-    },
-
-    swap: function swap(value) {
-      // remove old nodes
-      var i = this.nodes.length;
-      while (i--) {
-        remove(this.nodes[i]);
-      }
-      // convert new value to a fragment
-      // do not attempt to retrieve from id selector
-      var frag = parseTemplate(value, true, true);
-      // save a reference to these nodes so we can remove later
-      this.nodes = toArray(frag.childNodes);
-      before(frag, this.anchor);
-    }
-  };
-
-  /**
-   * Abstraction for a partially-compiled fragment.
-   * Can optionally compile content with a child scope.
-   *
-   * @param {Function} linker
-   * @param {Vue} vm
-   * @param {DocumentFragment} frag
-   * @param {Vue} [host]
-   * @param {Object} [scope]
-   * @param {Fragment} [parentFrag]
-   */
-  function Fragment(linker, vm, frag, host, scope, parentFrag) {
-    this.children = [];
-    this.childFrags = [];
-    this.vm = vm;
-    this.scope = scope;
-    this.inserted = false;
-    this.parentFrag = parentFrag;
-    if (parentFrag) {
-      parentFrag.childFrags.push(this);
-    }
-    this.unlink = linker(vm, frag, host, scope, this);
-    var single = this.single = frag.childNodes.length === 1 &&
-    // do not go single mode if the only node is an anchor
-    !frag.childNodes[0].__v_anchor;
-    if (single) {
-      this.node = frag.childNodes[0];
-      this.before = singleBefore;
-      this.remove = singleRemove;
-    } else {
-      this.node = createAnchor('fragment-start');
-      this.end = createAnchor('fragment-end');
-      this.frag = frag;
-      prepend(this.node, frag);
-      frag.appendChild(this.end);
-      this.before = multiBefore;
-      this.remove = multiRemove;
-    }
-    this.node.__v_frag = this;
-  }
-
-  /**
-   * Call attach/detach for all components contained within
-   * this fragment. Also do so recursively for all child
-   * fragments.
-   *
-   * @param {Function} hook
-   */
-
-  Fragment.prototype.callHook = function (hook) {
-    var i, l;
-    for (i = 0, l = this.childFrags.length; i < l; i++) {
-      this.childFrags[i].callHook(hook);
-    }
-    for (i = 0, l = this.children.length; i < l; i++) {
-      hook(this.children[i]);
-    }
-  };
-
-  /**
-   * Insert fragment before target, single node version
-   *
-   * @param {Node} target
-   * @param {Boolean} withTransition
-   */
-
-  function singleBefore(target, withTransition) {
-    this.inserted = true;
-    var method = withTransition !== false ? beforeWithTransition : before;
-    method(this.node, target, this.vm);
-    if (inDoc(this.node)) {
-      this.callHook(attach);
-    }
-  }
-
-  /**
-   * Remove fragment, single node version
-   */
-
-  function singleRemove() {
-    this.inserted = false;
-    var shouldCallRemove = inDoc(this.node);
-    var self = this;
-    this.beforeRemove();
-    removeWithTransition(this.node, this.vm, function () {
-      if (shouldCallRemove) {
-        self.callHook(detach);
-      }
-      self.destroy();
-    });
-  }
-
-  /**
-   * Insert fragment before target, multi-nodes version
-   *
-   * @param {Node} target
-   * @param {Boolean} withTransition
-   */
-
-  function multiBefore(target, withTransition) {
-    this.inserted = true;
-    var vm = this.vm;
-    var method = withTransition !== false ? beforeWithTransition : before;
-    mapNodeRange(this.node, this.end, function (node) {
-      method(node, target, vm);
-    });
-    if (inDoc(this.node)) {
-      this.callHook(attach);
-    }
-  }
-
-  /**
-   * Remove fragment, multi-nodes version
-   */
-
-  function multiRemove() {
-    this.inserted = false;
-    var self = this;
-    var shouldCallRemove = inDoc(this.node);
-    this.beforeRemove();
-    removeNodeRange(this.node, this.end, this.vm, this.frag, function () {
-      if (shouldCallRemove) {
-        self.callHook(detach);
-      }
-      self.destroy();
-    });
-  }
-
-  /**
-   * Prepare the fragment for removal.
-   */
-
-  Fragment.prototype.beforeRemove = function () {
-    var i, l;
-    for (i = 0, l = this.childFrags.length; i < l; i++) {
-      // call the same method recursively on child
-      // fragments, depth-first
-      this.childFrags[i].beforeRemove(false);
-    }
-    for (i = 0, l = this.children.length; i < l; i++) {
-      // Call destroy for all contained instances,
-      // with remove:false and defer:true.
-      // Defer is necessary because we need to
-      // keep the children to call detach hooks
-      // on them.
-      this.children[i].$destroy(false, true);
-    }
-    var dirs = this.unlink.dirs;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      // disable the watchers on all the directives
-      // so that the rendered content stays the same
-      // during removal.
-      dirs[i]._watcher && dirs[i]._watcher.teardown();
-    }
-  };
-
-  /**
-   * Destroy the fragment.
-   */
-
-  Fragment.prototype.destroy = function () {
-    if (this.parentFrag) {
-      this.parentFrag.childFrags.$remove(this);
-    }
-    this.node.__v_frag = null;
-    this.unlink();
-  };
-
-  /**
-   * Call attach hook for a Vue instance.
-   *
-   * @param {Vue} child
-   */
-
-  function attach(child) {
-    if (!child._isAttached && inDoc(child.$el)) {
-      child._callHook('attached');
-    }
-  }
-
-  /**
-   * Call detach hook for a Vue instance.
-   *
-   * @param {Vue} child
-   */
-
-  function detach(child) {
-    if (child._isAttached && !inDoc(child.$el)) {
-      child._callHook('detached');
-    }
-  }
-
-  var linkerCache = new Cache(5000);
-
-  /**
-   * A factory that can be used to create instances of a
-   * fragment. Caches the compiled linker if possible.
-   *
-   * @param {Vue} vm
-   * @param {Element|String} el
-   */
-  function FragmentFactory(vm, el) {
-    this.vm = vm;
-    var template;
-    var isString = typeof el === 'string';
-    if (isString || isTemplate(el) && !el.hasAttribute('v-if')) {
-      template = parseTemplate(el, true);
-    } else {
-      template = document.createDocumentFragment();
-      template.appendChild(el);
-    }
-    this.template = template;
-    // linker can be cached, but only for components
-    var linker;
-    var cid = vm.constructor.cid;
-    if (cid > 0) {
-      var cacheId = cid + (isString ? el : getOuterHTML(el));
-      linker = linkerCache.get(cacheId);
-      if (!linker) {
-        linker = compile(template, vm.$options, true);
-        linkerCache.put(cacheId, linker);
-      }
-    } else {
-      linker = compile(template, vm.$options, true);
-    }
-    this.linker = linker;
-  }
-
-  /**
-   * Create a fragment instance with given host and scope.
-   *
-   * @param {Vue} host
-   * @param {Object} scope
-   * @param {Fragment} parentFrag
-   */
-
-  FragmentFactory.prototype.create = function (host, scope, parentFrag) {
-    var frag = cloneNode(this.template);
-    return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag);
-  };
-
-  var ON = 700;
-  var MODEL = 800;
-  var BIND = 850;
-  var TRANSITION = 1100;
-  var EL = 1500;
-  var COMPONENT = 1500;
-  var PARTIAL = 1750;
-  var IF = 2100;
-  var FOR = 2200;
-  var SLOT = 2300;
-
-  var uid$3 = 0;
-
-  var vFor = {
-
-    priority: FOR,
-    terminal: true,
-
-    params: ['track-by', 'stagger', 'enter-stagger', 'leave-stagger'],
-
-    bind: function bind() {
-      // support "item in/of items" syntax
-      var inMatch = this.expression.match(/(.*) (?:in|of) (.*)/);
-      if (inMatch) {
-        var itMatch = inMatch[1].match(/\((.*),(.*)\)/);
-        if (itMatch) {
-          this.iterator = itMatch[1].trim();
-          this.alias = itMatch[2].trim();
-        } else {
-          this.alias = inMatch[1].trim();
-        }
-        this.expression = inMatch[2];
-      }
-
-      if (!this.alias) {
-        'development' !== 'production' && warn('Invalid v-for expression "' + this.descriptor.raw + '": ' + 'alias is required.', this.vm);
-        return;
-      }
-
-      // uid as a cache identifier
-      this.id = '__v-for__' + ++uid$3;
-
-      // check if this is an option list,
-      // so that we know if we need to update the <select>'s
-      // v-model when the option list has changed.
-      // because v-model has a lower priority than v-for,
-      // the v-model is not bound here yet, so we have to
-      // retrive it in the actual updateModel() function.
-      var tag = this.el.tagName;
-      this.isOption = (tag === 'OPTION' || tag === 'OPTGROUP') && this.el.parentNode.tagName === 'SELECT';
-
-      // setup anchor nodes
-      this.start = createAnchor('v-for-start');
-      this.end = createAnchor('v-for-end');
-      replace(this.el, this.end);
-      before(this.start, this.end);
-
-      // cache
-      this.cache = Object.create(null);
-
-      // fragment factory
-      this.factory = new FragmentFactory(this.vm, this.el);
-    },
-
-    update: function update(data) {
-      this.diff(data);
-      this.updateRef();
-      this.updateModel();
-    },
-
-    /**
-     * Diff, based on new data and old data, determine the
-     * minimum amount of DOM manipulations needed to make the
-     * DOM reflect the new data Array.
-     *
-     * The algorithm diffs the new data Array by storing a
-     * hidden reference to an owner vm instance on previously
-     * seen data. This allows us to achieve O(n) which is
-     * better than a levenshtein distance based algorithm,
-     * which is O(m * n).
-     *
-     * @param {Array} data
-     */
-
-    diff: function diff(data) {
-      // check if the Array was converted from an Object
-      var item = data[0];
-      var convertedFromObject = this.fromObject = isObject(item) && hasOwn(item, '$key') && hasOwn(item, '$value');
-
-      var trackByKey = this.params.trackBy;
-      var oldFrags = this.frags;
-      var frags = this.frags = new Array(data.length);
-      var alias = this.alias;
-      var iterator = this.iterator;
-      var start = this.start;
-      var end = this.end;
-      var inDocument = inDoc(start);
-      var init = !oldFrags;
-      var i, l, frag, key, value, primitive;
-
-      // First pass, go through the new Array and fill up
-      // the new frags array. If a piece of data has a cached
-      // instance for it, we reuse it. Otherwise build a new
-      // instance.
-      for (i = 0, l = data.length; i < l; i++) {
-        item = data[i];
-        key = convertedFromObject ? item.$key : null;
-        value = convertedFromObject ? item.$value : item;
-        primitive = !isObject(value);
-        frag = !init && this.getCachedFrag(value, i, key);
-        if (frag) {
-          // reusable fragment
-          frag.reused = true;
-          // update $index
-          frag.scope.$index = i;
-          // update $key
-          if (key) {
-            frag.scope.$key = key;
-          }
-          // update iterator
-          if (iterator) {
-            frag.scope[iterator] = key !== null ? key : i;
-          }
-          // update data for track-by, object repeat &
-          // primitive values.
-          if (trackByKey || convertedFromObject || primitive) {
-            withoutConversion(function () {
-              frag.scope[alias] = value;
-            });
-          }
-        } else {
-          // new isntance
-          frag = this.create(value, alias, i, key);
-          frag.fresh = !init;
-        }
-        frags[i] = frag;
-        if (init) {
-          frag.before(end);
-        }
-      }
-
-      // we're done for the initial render.
-      if (init) {
-        return;
-      }
-
-      // Second pass, go through the old fragments and
-      // destroy those who are not reused (and remove them
-      // from cache)
-      var removalIndex = 0;
-      var totalRemoved = oldFrags.length - frags.length;
-      // when removing a large number of fragments, watcher removal
-      // turns out to be a perf bottleneck, so we batch the watcher
-      // removals into a single filter call!
-      this.vm._vForRemoving = true;
-      for (i = 0, l = oldFrags.length; i < l; i++) {
-        frag = oldFrags[i];
-        if (!frag.reused) {
-          this.deleteCachedFrag(frag);
-          this.remove(frag, removalIndex++, totalRemoved, inDocument);
-        }
-      }
-      this.vm._vForRemoving = false;
-      if (removalIndex) {
-        this.vm._watchers = this.vm._watchers.filter(function (w) {
-          return w.active;
-        });
-      }
-
-      // Final pass, move/insert new fragments into the
-      // right place.
-      var targetPrev, prevEl, currentPrev;
-      var insertionIndex = 0;
-      for (i = 0, l = frags.length; i < l; i++) {
-        frag = frags[i];
-        // this is the frag that we should be after
-        targetPrev = frags[i - 1];
-        prevEl = targetPrev ? targetPrev.staggerCb ? targetPrev.staggerAnchor : targetPrev.end || targetPrev.node : start;
-        if (frag.reused && !frag.staggerCb) {
-          currentPrev = findPrevFrag(frag, start, this.id);
-          if (currentPrev !== targetPrev && (!currentPrev ||
-          // optimization for moving a single item.
-          // thanks to suggestions by @livoras in #1807
-          findPrevFrag(currentPrev, start, this.id) !== targetPrev)) {
-            this.move(frag, prevEl);
-          }
-        } else {
-          // new instance, or still in stagger.
-          // insert with updated stagger index.
-          this.insert(frag, insertionIndex++, prevEl, inDocument);
-        }
-        frag.reused = frag.fresh = false;
-      }
-    },
-
-    /**
-     * Create a new fragment instance.
-     *
-     * @param {*} value
-     * @param {String} alias
-     * @param {Number} index
-     * @param {String} [key]
-     * @return {Fragment}
-     */
-
-    create: function create(value, alias, index, key) {
-      var host = this._host;
-      // create iteration scope
-      var parentScope = this._scope || this.vm;
-      var scope = Object.create(parentScope);
-      // ref holder for the scope
-      scope.$refs = Object.create(parentScope.$refs);
-      scope.$els = Object.create(parentScope.$els);
-      // make sure point $parent to parent scope
-      scope.$parent = parentScope;
-      // for two-way binding on alias
-      scope.$forContext = this;
-      // define scope properties
-      // important: define the scope alias without forced conversion
-      // so that frozen data structures remain non-reactive.
-      withoutConversion(function () {
-        defineReactive(scope, alias, value);
-      });
-      defineReactive(scope, '$index', index);
-      if (key) {
-        defineReactive(scope, '$key', key);
-      } else if (scope.$key) {
-        // avoid accidental fallback
-        def(scope, '$key', null);
-      }
-      if (this.iterator) {
-        defineReactive(scope, this.iterator, key !== null ? key : index);
-      }
-      var frag = this.factory.create(host, scope, this._frag);
-      frag.forId = this.id;
-      this.cacheFrag(value, frag, index, key);
-      return frag;
-    },
-
-    /**
-     * Update the v-ref on owner vm.
-     */
-
-    updateRef: function updateRef() {
-      var ref = this.descriptor.ref;
-      if (!ref) return;
-      var hash = (this._scope || this.vm).$refs;
-      var refs;
-      if (!this.fromObject) {
-        refs = this.frags.map(findVmFromFrag);
-      } else {
-        refs = {};
-        this.frags.forEach(function (frag) {
-          refs[frag.scope.$key] = findVmFromFrag(frag);
-        });
-      }
-      hash[ref] = refs;
-    },
-
-    /**
-     * For option lists, update the containing v-model on
-     * parent <select>.
-     */
-
-    updateModel: function updateModel() {
-      if (this.isOption) {
-        var parent = this.start.parentNode;
-        var model = parent && parent.__v_model;
-        if (model) {
-          model.forceUpdate();
-        }
-      }
-    },
-
-    /**
-     * Insert a fragment. Handles staggering.
-     *
-     * @param {Fragment} frag
-     * @param {Number} index
-     * @param {Node} prevEl
-     * @param {Boolean} inDocument
-     */
-
-    insert: function insert(frag, index, prevEl, inDocument) {
-      if (frag.staggerCb) {
-        frag.staggerCb.cancel();
-        frag.staggerCb = null;
-      }
-      var staggerAmount = this.getStagger(frag, index, null, 'enter');
-      if (inDocument && staggerAmount) {
-        // create an anchor and insert it synchronously,
-        // so that we can resolve the correct order without
-        // worrying about some elements not inserted yet
-        var anchor = frag.staggerAnchor;
-        if (!anchor) {
-          anchor = frag.staggerAnchor = createAnchor('stagger-anchor');
-          anchor.__v_frag = frag;
-        }
-        after(anchor, prevEl);
-        var op = frag.staggerCb = cancellable(function () {
-          frag.staggerCb = null;
-          frag.before(anchor);
-          remove(anchor);
-        });
-        setTimeout(op, staggerAmount);
-      } else {
-        var target = prevEl.nextSibling;
-        /* istanbul ignore if */
-        if (!target) {
-          // reset end anchor position in case the position was messed up
-          // by an external drag-n-drop library.
-          after(this.end, prevEl);
-          target = this.end;
-        }
-        frag.before(target);
-      }
-    },
-
-    /**
-     * Remove a fragment. Handles staggering.
-     *
-     * @param {Fragment} frag
-     * @param {Number} index
-     * @param {Number} total
-     * @param {Boolean} inDocument
-     */
-
-    remove: function remove(frag, index, total, inDocument) {
-      if (frag.staggerCb) {
-        frag.staggerCb.cancel();
-        frag.staggerCb = null;
-        // it's not possible for the same frag to be removed
-        // twice, so if we have a pending stagger callback,
-        // it means this frag is queued for enter but removed
-        // before its transition started. Since it is already
-        // destroyed, we can just leave it in detached state.
-        return;
-      }
-      var staggerAmount = this.getStagger(frag, index, total, 'leave');
-      if (inDocument && staggerAmount) {
-        var op = frag.staggerCb = cancellable(function () {
-          frag.staggerCb = null;
-          frag.remove();
-        });
-        setTimeout(op, staggerAmount);
-      } else {
-        frag.remove();
-      }
-    },
-
-    /**
-     * Move a fragment to a new position.
-     * Force no transition.
-     *
-     * @param {Fragment} frag
-     * @param {Node} prevEl
-     */
-
-    move: function move(frag, prevEl) {
-      // fix a common issue with Sortable:
-      // if prevEl doesn't have nextSibling, this means it's
-      // been dragged after the end anchor. Just re-position
-      // the end anchor to the end of the container.
-      /* istanbul ignore if */
-      if (!prevEl.nextSibling) {
-        this.end.parentNode.appendChild(this.end);
-      }
-      frag.before(prevEl.nextSibling, false);
-    },
-
-    /**
-     * Cache a fragment using track-by or the object key.
-     *
-     * @param {*} value
-     * @param {Fragment} frag
-     * @param {Number} index
-     * @param {String} [key]
-     */
-
-    cacheFrag: function cacheFrag(value, frag, index, key) {
-      var trackByKey = this.params.trackBy;
-      var cache = this.cache;
-      var primitive = !isObject(value);
-      var id;
-      if (key || trackByKey || primitive) {
-        id = getTrackByKey(index, key, value, trackByKey);
-        if (!cache[id]) {
-          cache[id] = frag;
-        } else if (trackByKey !== '$index') {
-          'development' !== 'production' && this.warnDuplicate(value);
-        }
-      } else {
-        id = this.id;
-        if (hasOwn(value, id)) {
-          if (value[id] === null) {
-            value[id] = frag;
-          } else {
-            'development' !== 'production' && this.warnDuplicate(value);
-          }
-        } else if (Object.isExtensible(value)) {
-          def(value, id, frag);
-        } else if ('development' !== 'production') {
-          warn('Frozen v-for objects cannot be automatically tracked, make sure to ' + 'provide a track-by key.');
-        }
-      }
-      frag.raw = value;
-    },
-
-    /**
-     * Get a cached fragment from the value/index/key
-     *
-     * @param {*} value
-     * @param {Number} index
-     * @param {String} key
-     * @return {Fragment}
-     */
-
-    getCachedFrag: function getCachedFrag(value, index, key) {
-      var trackByKey = this.params.trackBy;
-      var primitive = !isObject(value);
-      var frag;
-      if (key || trackByKey || primitive) {
-        var id = getTrackByKey(index, key, value, trackByKey);
-        frag = this.cache[id];
-      } else {
-        frag = value[this.id];
-      }
-      if (frag && (frag.reused || frag.fresh)) {
-        'development' !== 'production' && this.warnDuplicate(value);
-      }
-      return frag;
-    },
-
-    /**
-     * Delete a fragment from cache.
-     *
-     * @param {Fragment} frag
-     */
-
-    deleteCachedFrag: function deleteCachedFrag(frag) {
-      var value = frag.raw;
-      var trackByKey = this.params.trackBy;
-      var scope = frag.scope;
-      var index = scope.$index;
-      // fix #948: avoid accidentally fall through to
-      // a parent repeater which happens to have $key.
-      var key = hasOwn(scope, '$key') && scope.$key;
-      var primitive = !isObject(value);
-      if (trackByKey || key || primitive) {
-        var id = getTrackByKey(index, key, value, trackByKey);
-        this.cache[id] = null;
-      } else {
-        value[this.id] = null;
-        frag.raw = null;
-      }
-    },
-
-    /**
-     * Get the stagger amount for an insertion/removal.
-     *
-     * @param {Fragment} frag
-     * @param {Number} index
-     * @param {Number} total
-     * @param {String} type
-     */
-
-    getStagger: function getStagger(frag, index, total, type) {
-      type = type + 'Stagger';
-      var trans = frag.node.__v_trans;
-      var hooks = trans && trans.hooks;
-      var hook = hooks && (hooks[type] || hooks.stagger);
-      return hook ? hook.call(frag, index, total) : index * parseInt(this.params[type] || this.params.stagger, 10);
-    },
-
-    /**
-     * Pre-process the value before piping it through the
-     * filters. This is passed to and called by the watcher.
-     */
-
-    _preProcess: function _preProcess(value) {
-      // regardless of type, store the un-filtered raw value.
-      this.rawValue = value;
-      return value;
-    },
-
-    /**
-     * Post-process the value after it has been piped through
-     * the filters. This is passed to and called by the watcher.
-     *
-     * It is necessary for this to be called during the
-     * watcher's dependency collection phase because we want
-     * the v-for to update when the source Object is mutated.
-     */
-
-    _postProcess: function _postProcess(value) {
-      if (isArray(value)) {
-        return value;
-      } else if (isPlainObject(value)) {
-        // convert plain object to array.
-        var keys = Object.keys(value);
-        var i = keys.length;
-        var res = new Array(i);
-        var key;
-        while (i--) {
-          key = keys[i];
-          res[i] = {
-            $key: key,
-            $value: value[key]
-          };
-        }
-        return res;
-      } else {
-        if (typeof value === 'number' && !isNaN(value)) {
-          value = range(value);
-        }
-        return value || [];
-      }
-    },
-
-    unbind: function unbind() {
-      if (this.descriptor.ref) {
-        (this._scope || this.vm).$refs[this.descriptor.ref] = null;
-      }
-      if (this.frags) {
-        var i = this.frags.length;
-        var frag;
-        while (i--) {
-          frag = this.frags[i];
-          this.deleteCachedFrag(frag);
-          frag.destroy();
-        }
-      }
-    }
-  };
-
-  /**
-   * Helper to find the previous element that is a fragment
-   * anchor. This is necessary because a destroyed frag's
-   * element could still be lingering in the DOM before its
-   * leaving transition finishes, but its inserted flag
-   * should have been set to false so we can skip them.
-   *
-   * If this is a block repeat, we want to make sure we only
-   * return frag that is bound to this v-for. (see #929)
-   *
-   * @param {Fragment} frag
-   * @param {Comment|Text} anchor
-   * @param {String} id
-   * @return {Fragment}
-   */
-
-  function findPrevFrag(frag, anchor, id) {
-    var el = frag.node.previousSibling;
-    /* istanbul ignore if */
-    if (!el) return;
-    frag = el.__v_frag;
-    while ((!frag || frag.forId !== id || !frag.inserted) && el !== anchor) {
-      el = el.previousSibling;
-      /* istanbul ignore if */
-      if (!el) return;
-      frag = el.__v_frag;
-    }
-    return frag;
-  }
-
-  /**
-   * Find a vm from a fragment.
-   *
-   * @param {Fragment} frag
-   * @return {Vue|undefined}
-   */
-
-  function findVmFromFrag(frag) {
-    var node = frag.node;
-    // handle multi-node frag
-    if (frag.end) {
-      while (!node.__vue__ && node !== frag.end && node.nextSibling) {
-        node = node.nextSibling;
-      }
-    }
-    return node.__vue__;
-  }
-
-  /**
-   * Create a range array from given number.
-   *
-   * @param {Number} n
-   * @return {Array}
-   */
-
-  function range(n) {
-    var i = -1;
-    var ret = new Array(Math.floor(n));
-    while (++i < n) {
-      ret[i] = i;
-    }
-    return ret;
-  }
-
-  /**
-   * Get the track by key for an item.
-   *
-   * @param {Number} index
-   * @param {String} key
-   * @param {*} value
-   * @param {String} [trackByKey]
-   */
-
-  function getTrackByKey(index, key, value, trackByKey) {
-    return trackByKey ? trackByKey === '$index' ? index : trackByKey.charAt(0).match(/\w/) ? getPath(value, trackByKey) : value[trackByKey] : key || value;
-  }
-
-  if ('development' !== 'production') {
-    vFor.warnDuplicate = function (value) {
-      warn('Duplicate value found in v-for="' + this.descriptor.raw + '": ' + JSON.stringify(value) + '. Use track-by="$index" if ' + 'you are expecting duplicate values.', this.vm);
-    };
-  }
-
-  var vIf = {
-
-    priority: IF,
-    terminal: true,
-
-    bind: function bind() {
-      var el = this.el;
-      if (!el.__vue__) {
-        // check else block
-        var next = el.nextElementSibling;
-        if (next && getAttr(next, 'v-else') !== null) {
-          remove(next);
-          this.elseEl = next;
-        }
-        // check main block
-        this.anchor = createAnchor('v-if');
-        replace(el, this.anchor);
-      } else {
-        'development' !== 'production' && warn('v-if="' + this.expression + '" cannot be ' + 'used on an instance root element.', this.vm);
-        this.invalid = true;
-      }
-    },
-
-    update: function update(value) {
-      if (this.invalid) return;
-      if (value) {
-        if (!this.frag) {
-          this.insert();
-        }
-      } else {
-        this.remove();
-      }
-    },
-
-    insert: function insert() {
-      if (this.elseFrag) {
-        this.elseFrag.remove();
-        this.elseFrag = null;
-      }
-      // lazy init factory
-      if (!this.factory) {
-        this.factory = new FragmentFactory(this.vm, this.el);
-      }
-      this.frag = this.factory.create(this._host, this._scope, this._frag);
-      this.frag.before(this.anchor);
-    },
-
-    remove: function remove() {
-      if (this.frag) {
-        this.frag.remove();
-        this.frag = null;
-      }
-      if (this.elseEl && !this.elseFrag) {
-        if (!this.elseFactory) {
-          this.elseFactory = new FragmentFactory(this.elseEl._context || this.vm, this.elseEl);
-        }
-        this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag);
-        this.elseFrag.before(this.anchor);
-      }
-    },
-
-    unbind: function unbind() {
-      if (this.frag) {
-        this.frag.destroy();
-      }
-      if (this.elseFrag) {
-        this.elseFrag.destroy();
-      }
-    }
-  };
-
-  var show = {
-
-    bind: function bind() {
-      // check else block
-      var next = this.el.nextElementSibling;
-      if (next && getAttr(next, 'v-else') !== null) {
-        this.elseEl = next;
-      }
-    },
-
-    update: function update(value) {
-      this.apply(this.el, value);
-      if (this.elseEl) {
-        this.apply(this.elseEl, !value);
-      }
-    },
-
-    apply: function apply(el, value) {
-      if (inDoc(el)) {
-        applyTransition(el, value ? 1 : -1, toggle, this.vm);
-      } else {
-        toggle();
-      }
-      function toggle() {
-        el.style.display = value ? '' : 'none';
-      }
-    }
-  };
-
-  var text$2 = {
-
-    bind: function bind() {
-      var self = this;
-      var el = this.el;
-      var isRange = el.type === 'range';
-      var lazy = this.params.lazy;
-      var number = this.params.number;
-      var debounce = this.params.debounce;
-
-      // handle composition events.
-      //   http://blog.evanyou.me/2014/01/03/composition-event/
-      // skip this for Android because it handles composition
-      // events quite differently. Android doesn't trigger
-      // composition events for language input methods e.g.
-      // Chinese, but instead triggers them for spelling
-      // suggestions... (see Discussion/#162)
-      var composing = false;
-      if (!isAndroid && !isRange) {
-        this.on('compositionstart', function () {
-          composing = true;
-        });
-        this.on('compositionend', function () {
-          composing = false;
-          // in IE11 the "compositionend" event fires AFTER
-          // the "input" event, so the input handler is blocked
-          // at the end... have to call it here.
-          //
-          // #1327: in lazy mode this is unecessary.
-          if (!lazy) {
-            self.listener();
-          }
-        });
-      }
-
-      // prevent messing with the input when user is typing,
-      // and force update on blur.
-      this.focused = false;
-      if (!isRange && !lazy) {
-        this.on('focus', function () {
-          self.focused = true;
-        });
-        this.on('blur', function () {
-          self.focused = false;
-          // do not sync value after fragment removal (#2017)
-          if (!self._frag || self._frag.inserted) {
-            self.rawListener();
-          }
-        });
-      }
-
-      // Now attach the main listener
-      this.listener = this.rawListener = function () {
-        if (composing || !self._bound) {
-          return;
-        }
-        var val = number || isRange ? toNumber(el.value) : el.value;
-        self.set(val);
-        // force update on next tick to avoid lock & same value
-        // also only update when user is not typing
-        nextTick(function () {
-          if (self._bound && !self.focused) {
-            self.update(self._watcher.value);
-          }
-        });
-      };
-
-      // apply debounce
-      if (debounce) {
-        this.listener = _debounce(this.listener, debounce);
-      }
-
-      // Support jQuery events, since jQuery.trigger() doesn't
-      // trigger native events in some cases and some plugins
-      // rely on $.trigger()
-      //
-      // We want to make sure if a listener is attached using
-      // jQuery, it is also removed with jQuery, that's why
-      // we do the check for each directive instance and
-      // store that check result on itself. This also allows
-      // easier test coverage control by unsetting the global
-      // jQuery variable in tests.
-      this.hasjQuery = typeof jQuery === 'function';
-      if (this.hasjQuery) {
-        var method = jQuery.fn.on ? 'on' : 'bind';
-        jQuery(el)[method]('change', this.rawListener);
-        if (!lazy) {
-          jQuery(el)[method]('input', this.listener);
-        }
-      } else {
-        this.on('change', this.rawListener);
-        if (!lazy) {
-          this.on('input', this.listener);
-        }
-      }
-
-      // IE9 doesn't fire input event on backspace/del/cut
-      if (!lazy && isIE9) {
-        this.on('cut', function () {
-          nextTick(self.listener);
-        });
-        this.on('keyup', function (e) {
-          if (e.keyCode === 46 || e.keyCode === 8) {
-            self.listener();
-          }
-        });
-      }
-
-      // set initial value if present
-      if (el.hasAttribute('value') || el.tagName === 'TEXTAREA' && el.value.trim()) {
-        this.afterBind = this.listener;
-      }
-    },
-
-    update: function update(value) {
-      // #3029 only update when the value changes. This prevent
-      // browsers from overwriting values like selectionStart
-      value = _toString(value);
-      if (value !== this.el.value) this.el.value = value;
-    },
-
-    unbind: function unbind() {
-      var el = this.el;
-      if (this.hasjQuery) {
-        var method = jQuery.fn.off ? 'off' : 'unbind';
-        jQuery(el)[method]('change', this.listener);
-        jQuery(el)[method]('input', this.listener);
-      }
-    }
-  };
-
-  var radio = {
-
-    bind: function bind() {
-      var self = this;
-      var el = this.el;
-
-      this.getValue = function () {
-        // value overwrite via v-bind:value
-        if (el.hasOwnProperty('_value')) {
-          return el._value;
-        }
-        var val = el.value;
-        if (self.params.number) {
-          val = toNumber(val);
-        }
-        return val;
-      };
-
-      this.listener = function () {
-        self.set(self.getValue());
-      };
-      this.on('change', this.listener);
-
-      if (el.hasAttribute('checked')) {
-        this.afterBind = this.listener;
-      }
-    },
-
-    update: function update(value) {
-      this.el.checked = looseEqual(value, this.getValue());
-    }
-  };
-
-  var select = {
-
-    bind: function bind() {
-      var _this = this;
-
-      var self = this;
-      var el = this.el;
-
-      // method to force update DOM using latest value.
-      this.forceUpdate = function () {
-        if (self._watcher) {
-          self.update(self._watcher.get());
-        }
-      };
-
-      // check if this is a multiple select
-      var multiple = this.multiple = el.hasAttribute('multiple');
-
-      // attach listener
-      this.listener = function () {
-        var value = getValue(el, multiple);
-        value = self.params.number ? isArray(value) ? value.map(toNumber) : toNumber(value) : value;
-        self.set(value);
-      };
-      this.on('change', this.listener);
-
-      // if has initial value, set afterBind
-      var initValue = getValue(el, multiple, true);
-      if (multiple && initValue.length || !multiple && initValue !== null) {
-        this.afterBind = this.listener;
-      }
-
-      // All major browsers except Firefox resets
-      // selectedIndex with value -1 to 0 when the element
-      // is appended to a new parent, therefore we have to
-      // force a DOM update whenever that happens...
-      this.vm.$on('hook:attached', function () {
-        nextTick(_this.forceUpdate);
-      });
-      if (!inDoc(el)) {
-        nextTick(this.forceUpdate);
-      }
-    },
-
-    update: function update(value) {
-      var el = this.el;
-      el.selectedIndex = -1;
-      var multi = this.multiple && isArray(value);
-      var options = el.options;
-      var i = options.length;
-      var op, val;
-      while (i--) {
-        op = options[i];
-        val = op.hasOwnProperty('_value') ? op._value : op.value;
-        /* eslint-disable eqeqeq */
-        op.selected = multi ? indexOf$1(value, val) > -1 : looseEqual(value, val);
-        /* eslint-enable eqeqeq */
-      }
-    },
-
-    unbind: function unbind() {
-      /* istanbul ignore next */
-      this.vm.$off('hook:attached', this.forceUpdate);
-    }
-  };
-
-  /**
-   * Get select value
-   *
-   * @param {SelectElement} el
-   * @param {Boolean} multi
-   * @param {Boolean} init
-   * @return {Array|*}
-   */
-
-  function getValue(el, multi, init) {
-    var res = multi ? [] : null;
-    var op, val, selected;
-    for (var i = 0, l = el.options.length; i < l; i++) {
-      op = el.options[i];
-      selected = init ? op.hasAttribute('selected') : op.selected;
-      if (selected) {
-        val = op.hasOwnProperty('_value') ? op._value : op.value;
-        if (multi) {
-          res.push(val);
-        } else {
-          return val;
-        }
-      }
-    }
-    return res;
-  }
-
-  /**
-   * Native Array.indexOf uses strict equal, but in this
-   * case we need to match string/numbers with custom equal.
-   *
-   * @param {Array} arr
-   * @param {*} val
-   */
-
-  function indexOf$1(arr, val) {
-    var i = arr.length;
-    while (i--) {
-      if (looseEqual(arr[i], val)) {
-        return i;
-      }
-    }
-    return -1;
-  }
-
-  var checkbox = {
-
-    bind: function bind() {
-      var self = this;
-      var el = this.el;
-
-      this.getValue = function () {
-        return el.hasOwnProperty('_value') ? el._value : self.params.number ? toNumber(el.value) : el.value;
-      };
-
-      function getBooleanValue() {
-        var val = el.checked;
-        if (val && el.hasOwnProperty('_trueValue')) {
-          return el._trueValue;
-        }
-        if (!val && el.hasOwnProperty('_falseValue')) {
-          return el._falseValue;
-        }
-        return val;
-      }
-
-      this.listener = function () {
-        var model = self._watcher.value;
-        if (isArray(model)) {
-          var val = self.getValue();
-          if (el.checked) {
-            if (indexOf(model, val) < 0) {
-              model.push(val);
-            }
-          } else {
-            model.$remove(val);
-          }
-        } else {
-          self.set(getBooleanValue());
-        }
-      };
-
-      this.on('change', this.listener);
-      if (el.hasAttribute('checked')) {
-        this.afterBind = this.listener;
-      }
-    },
-
-    update: function update(value) {
-      var el = this.el;
-      if (isArray(value)) {
-        el.checked = indexOf(value, this.getValue()) > -1;
-      } else {
-        if (el.hasOwnProperty('_trueValue')) {
-          el.checked = looseEqual(value, el._trueValue);
-        } else {
-          el.checked = !!value;
-        }
-      }
-    }
-  };
-
-  var handlers = {
-    text: text$2,
-    radio: radio,
-    select: select,
-    checkbox: checkbox
-  };
-
-  var model = {
-
-    priority: MODEL,
-    twoWay: true,
-    handlers: handlers,
-    params: ['lazy', 'number', 'debounce'],
-
-    /**
-     * Possible elements:
-     *   <select>
-     *   <textarea>
-     *   <input type="*">
-     *     - text
-     *     - checkbox
-     *     - radio
-     *     - number
-     */
-
-    bind: function bind() {
-      // friendly warning...
-      this.checkFilters();
-      if (this.hasRead && !this.hasWrite) {
-        'development' !== 'production' && warn('It seems you are using a read-only filter with ' + 'v-model="' + this.descriptor.raw + '". ' + 'You might want to use a two-way filter to ensure correct behavior.', this.vm);
-      }
-      var el = this.el;
-      var tag = el.tagName;
-      var handler;
-      if (tag === 'INPUT') {
-        handler = handlers[el.type] || handlers.text;
-      } else if (tag === 'SELECT') {
-        handler = handlers.select;
-      } else if (tag === 'TEXTAREA') {
-        handler = handlers.text;
-      } else {
-        'development' !== 'production' && warn('v-model does not support element type: ' + tag, this.vm);
-        return;
-      }
-      el.__v_model = this;
-      handler.bind.call(this);
-      this.update = handler.update;
-      this._unbind = handler.unbind;
-    },
-
-    /**
-     * Check read/write filter stats.
-     */
-
-    checkFilters: function checkFilters() {
-      var filters = this.filters;
-      if (!filters) return;
-      var i = filters.length;
-      while (i--) {
-        var filter = resolveAsset(this.vm.$options, 'filters', filters[i].name);
-        if (typeof filter === 'function' || filter.read) {
-          this.hasRead = true;
-        }
-        if (filter.write) {
-          this.hasWrite = true;
-        }
-      }
-    },
-
-    unbind: function unbind() {
-      this.el.__v_model = null;
-      this._unbind && this._unbind();
-    }
-  };
-
-  // keyCode aliases
-  var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    'delete': [8, 46],
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40
-  };
-
-  function keyFilter(handler, keys) {
-    var codes = keys.map(function (key) {
-      var charCode = key.charCodeAt(0);
-      if (charCode > 47 && charCode < 58) {
-        return parseInt(key, 10);
-      }
-      if (key.length === 1) {
-        charCode = key.toUpperCase().charCodeAt(0);
-        if (charCode > 64 && charCode < 91) {
-          return charCode;
-        }
-      }
-      return keyCodes[key];
-    });
-    codes = [].concat.apply([], codes);
-    return function keyHandler(e) {
-      if (codes.indexOf(e.keyCode) > -1) {
-        return handler.call(this, e);
-      }
-    };
-  }
-
-  function stopFilter(handler) {
-    return function stopHandler(e) {
-      e.stopPropagation();
-      return handler.call(this, e);
-    };
-  }
-
-  function preventFilter(handler) {
-    return function preventHandler(e) {
-      e.preventDefault();
-      return handler.call(this, e);
-    };
-  }
-
-  function selfFilter(handler) {
-    return function selfHandler(e) {
-      if (e.target === e.currentTarget) {
-        return handler.call(this, e);
-      }
-    };
-  }
-
-  var on$1 = {
-
-    priority: ON,
-    acceptStatement: true,
-    keyCodes: keyCodes,
-
-    bind: function bind() {
-      // deal with iframes
-      if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {
-        var self = this;
-        this.iframeBind = function () {
-          on(self.el.contentWindow, self.arg, self.handler, self.modifiers.capture);
-        };
-        this.on('load', this.iframeBind);
-      }
-    },
-
-    update: function update(handler) {
-      // stub a noop for v-on with no value,
-      // e.g. @mousedown.prevent
-      if (!this.descriptor.raw) {
-        handler = function () {};
-      }
-
-      if (typeof handler !== 'function') {
-        'development' !== 'production' && warn('v-on:' + this.arg + '="' + this.expression + '" expects a function value, ' + 'got ' + handler, this.vm);
-        return;
-      }
-
-      // apply modifiers
-      if (this.modifiers.stop) {
-        handler = stopFilter(handler);
-      }
-      if (this.modifiers.prevent) {
-        handler = preventFilter(handler);
-      }
-      if (this.modifiers.self) {
-        handler = selfFilter(handler);
-      }
-      // key filter
-      var keys = Object.keys(this.modifiers).filter(function (key) {
-        return key !== 'stop' && key !== 'prevent' && key !== 'self' && key !== 'capture';
-      });
-      if (keys.length) {
-        handler = keyFilter(handler, keys);
-      }
-
-      this.reset();
-      this.handler = handler;
-
-      if (this.iframeBind) {
-        this.iframeBind();
-      } else {
-        on(this.el, this.arg, this.handler, this.modifiers.capture);
-      }
-    },
-
-    reset: function reset() {
-      var el = this.iframeBind ? this.el.contentWindow : this.el;
-      if (this.handler) {
-        off(el, this.arg, this.handler);
-      }
-    },
-
-    unbind: function unbind() {
-      this.reset();
-    }
-  };
-
-  var prefixes = ['-webkit-', '-moz-', '-ms-'];
-  var camelPrefixes = ['Webkit', 'Moz', 'ms'];
-  var importantRE = /!important;?$/;
-  var propCache = Object.create(null);
-
-  var testEl = null;
-
-  var style = {
-
-    deep: true,
-
-    update: function update(value) {
-      if (typeof value === 'string') {
-        this.el.style.cssText = value;
-      } else if (isArray(value)) {
-        this.handleObject(value.reduce(extend, {}));
-      } else {
-        this.handleObject(value || {});
-      }
-    },
-
-    handleObject: function handleObject(value) {
-      // cache object styles so that only changed props
-      // are actually updated.
-      var cache = this.cache || (this.cache = {});
-      var name, val;
-      for (name in cache) {
-        if (!(name in value)) {
-          this.handleSingle(name, null);
-          delete cache[name];
-        }
-      }
-      for (name in value) {
-        val = value[name];
-        if (val !== cache[name]) {
-          cache[name] = val;
-          this.handleSingle(name, val);
-        }
-      }
-    },
-
-    handleSingle: function handleSingle(prop, value) {
-      prop = normalize(prop);
-      if (!prop) return; // unsupported prop
-      // cast possible numbers/booleans into strings
-      if (value != null) value += '';
-      if (value) {
-        var isImportant = importantRE.test(value) ? 'important' : '';
-        if (isImportant) {
-          /* istanbul ignore if */
-          if ('development' !== 'production') {
-            warn('It\'s probably a bad idea to use !important with inline rules. ' + 'This feature will be deprecated in a future version of Vue.');
-          }
-          value = value.replace(importantRE, '').trim();
-          this.el.style.setProperty(prop.kebab, value, isImportant);
-        } else {
-          this.el.style[prop.camel] = value;
-        }
-      } else {
-        this.el.style[prop.camel] = '';
-      }
-    }
-
-  };
-
-  /**
-   * Normalize a CSS property name.
-   * - cache result
-   * - auto prefix
-   * - camelCase -> dash-case
-   *
-   * @param {String} prop
-   * @return {String}
-   */
-
-  function normalize(prop) {
-    if (propCache[prop]) {
-      return propCache[prop];
-    }
-    var res = prefix(prop);
-    propCache[prop] = propCache[res] = res;
-    return res;
-  }
-
-  /**
-   * Auto detect the appropriate prefix for a CSS property.
-   * https://gist.github.com/paulirish/523692
-   *
-   * @param {String} prop
-   * @return {String}
-   */
-
-  function prefix(prop) {
-    prop = hyphenate(prop);
-    var camel = camelize(prop);
-    var upper = camel.charAt(0).toUpperCase() + camel.slice(1);
-    if (!testEl) {
-      testEl = document.createElement('div');
-    }
-    var i = prefixes.length;
-    var prefixed;
-    if (camel !== 'filter' && camel in testEl.style) {
-      return {
-        kebab: prop,
-        camel: camel
-      };
-    }
-    while (i--) {
-      prefixed = camelPrefixes[i] + upper;
-      if (prefixed in testEl.style) {
-        return {
-          kebab: prefixes[i] + prop,
-          camel: prefixed
-        };
-      }
-    }
-  }
-
-  // xlink
-  var xlinkNS = 'http://www.w3.org/1999/xlink';
-  var xlinkRE = /^xlink:/;
-
-  // check for attributes that prohibit interpolations
-  var disallowedInterpAttrRE = /^v-|^:|^@|^(?:is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/;
-  // these attributes should also set their corresponding properties
-  // because they only affect the initial state of the element
-  var attrWithPropsRE = /^(?:value|checked|selected|muted)$/;
-  // these attributes expect enumrated values of "true" or "false"
-  // but are not boolean attributes
-  var enumeratedAttrRE = /^(?:draggable|contenteditable|spellcheck)$/;
-
-  // these attributes should set a hidden property for
-  // binding v-model to object values
-  var modelProps = {
-    value: '_value',
-    'true-value': '_trueValue',
-    'false-value': '_falseValue'
-  };
-
-  var bind$1 = {
-
-    priority: BIND,
-
-    bind: function bind() {
-      var attr = this.arg;
-      var tag = this.el.tagName;
-      // should be deep watch on object mode
-      if (!attr) {
-        this.deep = true;
-      }
-      // handle interpolation bindings
-      var descriptor = this.descriptor;
-      var tokens = descriptor.interp;
-      if (tokens) {
-        // handle interpolations with one-time tokens
-        if (descriptor.hasOneTime) {
-          this.expression = tokensToExp(tokens, this._scope || this.vm);
-        }
-
-        // only allow binding on native attributes
-        if (disallowedInterpAttrRE.test(attr) || attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT')) {
-          'development' !== 'production' && warn(attr + '="' + descriptor.raw + '": ' + 'attribute interpolation is not allowed in Vue.js ' + 'directives and special attributes.', this.vm);
-          this.el.removeAttribute(attr);
-          this.invalid = true;
-        }
-
-        /* istanbul ignore if */
-        if ('development' !== 'production') {
-          var raw = attr + '="' + descriptor.raw + '": ';
-          // warn src
-          if (attr === 'src') {
-            warn(raw + 'interpolation in "src" attribute will cause ' + 'a 404 request. Use v-bind:src instead.', this.vm);
-          }
-
-          // warn style
-          if (attr === 'style') {
-            warn(raw + 'interpolation in "style" attribute will cause ' + 'the attribute to be discarded in Internet Explorer. ' + 'Use v-bind:style instead.', this.vm);
-          }
-        }
-      }
-    },
-
-    update: function update(value) {
-      if (this.invalid) {
-        return;
-      }
-      var attr = this.arg;
-      if (this.arg) {
-        this.handleSingle(attr, value);
-      } else {
-        this.handleObject(value || {});
-      }
-    },
-
-    // share object handler with v-bind:class
-    handleObject: style.handleObject,
-
-    handleSingle: function handleSingle(attr, value) {
-      var el = this.el;
-      var interp = this.descriptor.interp;
-      if (this.modifiers.camel) {
-        attr = camelize(attr);
-      }
-      if (!interp && attrWithPropsRE.test(attr) && attr in el) {
-        var attrValue = attr === 'value' ? value == null // IE9 will set input.value to "null" for null...
-        ? '' : value : value;
-
-        if (el[attr] !== attrValue) {
-          el[attr] = attrValue;
-        }
-      }
-      // set model props
-      var modelProp = modelProps[attr];
-      if (!interp && modelProp) {
-        el[modelProp] = value;
-        // update v-model if present
-        var model = el.__v_model;
-        if (model) {
-          model.listener();
-        }
-      }
-      // do not set value attribute for textarea
-      if (attr === 'value' && el.tagName === 'TEXTAREA') {
-        el.removeAttribute(attr);
-        return;
-      }
-      // update attribute
-      if (enumeratedAttrRE.test(attr)) {
-        el.setAttribute(attr, value ? 'true' : 'false');
-      } else if (value != null && value !== false) {
-        if (attr === 'class') {
-          // handle edge case #1960:
-          // class interpolation should not overwrite Vue transition class
-          if (el.__v_trans) {
-            value += ' ' + el.__v_trans.id + '-transition';
-          }
-          setClass(el, value);
-        } else if (xlinkRE.test(attr)) {
-          el.setAttributeNS(xlinkNS, attr, value === true ? '' : value);
-        } else {
-          el.setAttribute(attr, value === true ? '' : value);
-        }
-      } else {
-        el.removeAttribute(attr);
-      }
-    }
-  };
-
-  var el = {
-
-    priority: EL,
-
-    bind: function bind() {
-      /* istanbul ignore if */
-      if (!this.arg) {
-        return;
-      }
-      var id = this.id = camelize(this.arg);
-      var refs = (this._scope || this.vm).$els;
-      if (hasOwn(refs, id)) {
-        refs[id] = this.el;
-      } else {
-        defineReactive(refs, id, this.el);
-      }
-    },
-
-    unbind: function unbind() {
-      var refs = (this._scope || this.vm).$els;
-      if (refs[this.id] === this.el) {
-        refs[this.id] = null;
-      }
-    }
-  };
-
-  var ref = {
-    bind: function bind() {
-      'development' !== 'production' && warn('v-ref:' + this.arg + ' must be used on a child ' + 'component. Found on <' + this.el.tagName.toLowerCase() + '>.', this.vm);
-    }
-  };
-
-  var cloak = {
-    bind: function bind() {
-      var el = this.el;
-      this.vm.$once('pre-hook:compiled', function () {
-        el.removeAttribute('v-cloak');
-      });
-    }
-  };
-
-  // must export plain object
-  var directives = {
-    text: text$1,
-    html: html,
-    'for': vFor,
-    'if': vIf,
-    show: show,
-    model: model,
-    on: on$1,
-    bind: bind$1,
-    el: el,
-    ref: ref,
-    cloak: cloak
-  };
-
-  var vClass = {
-
-    deep: true,
-
-    update: function update(value) {
-      if (!value) {
-        this.cleanup();
-      } else if (typeof value === 'string') {
-        this.setClass(value.trim().split(/\s+/));
-      } else {
-        this.setClass(normalize$1(value));
-      }
-    },
-
-    setClass: function setClass(value) {
-      this.cleanup(value);
-      for (var i = 0, l = value.length; i < l; i++) {
-        var val = value[i];
-        if (val) {
-          apply(this.el, val, addClass);
-        }
-      }
-      this.prevKeys = value;
-    },
-
-    cleanup: function cleanup(value) {
-      var prevKeys = this.prevKeys;
-      if (!prevKeys) return;
-      var i = prevKeys.length;
-      while (i--) {
-        var key = prevKeys[i];
-        if (!value || value.indexOf(key) < 0) {
-          apply(this.el, key, removeClass);
-        }
-      }
-    }
-  };
-
-  /**
-   * Normalize objects and arrays (potentially containing objects)
-   * into array of strings.
-   *
-   * @param {Object|Array<String|Object>} value
-   * @return {Array<String>}
-   */
-
-  function normalize$1(value) {
-    var res = [];
-    if (isArray(value)) {
-      for (var i = 0, l = value.length; i < l; i++) {
-        var _key = value[i];
-        if (_key) {
-          if (typeof _key === 'string') {
-            res.push(_key);
-          } else {
-            for (var k in _key) {
-              if (_key[k]) res.push(k);
-            }
-          }
-        }
-      }
-    } else if (isObject(value)) {
-      for (var key in value) {
-        if (value[key]) res.push(key);
-      }
-    }
-    return res;
-  }
-
-  /**
-   * Add or remove a class/classes on an element
-   *
-   * @param {Element} el
-   * @param {String} key The class name. This may or may not
-   *                     contain a space character, in such a
-   *                     case we'll deal with multiple class
-   *                     names at once.
-   * @param {Function} fn
-   */
-
-  function apply(el, key, fn) {
-    key = key.trim();
-    if (key.indexOf(' ') === -1) {
-      fn(el, key);
-      return;
-    }
-    // The key contains one or more space characters.
-    // Since a class name doesn't accept such characters, we
-    // treat it as multiple classes.
-    var keys = key.split(/\s+/);
-    for (var i = 0, l = keys.length; i < l; i++) {
-      fn(el, keys[i]);
-    }
-  }
-
-  var component = {
-
-    priority: COMPONENT,
-
-    params: ['keep-alive', 'transition-mode', 'inline-template'],
-
-    /**
-     * Setup. Two possible usages:
-     *
-     * - static:
-     *   <comp> or <div v-component="comp">
-     *
-     * - dynamic:
-     *   <component :is="view">
-     */
-
-    bind: function bind() {
-      if (!this.el.__vue__) {
-        // keep-alive cache
-        this.keepAlive = this.params.keepAlive;
-        if (this.keepAlive) {
-          this.cache = {};
-        }
-        // check inline-template
-        if (this.params.inlineTemplate) {
-          // extract inline template as a DocumentFragment
-          this.inlineTemplate = extractContent(this.el, true);
-        }
-        // component resolution related state
-        this.pendingComponentCb = this.Component = null;
-        // transition related state
-        this.pendingRemovals = 0;
-        this.pendingRemovalCb = null;
-        // create a ref anchor
-        this.anchor = createAnchor('v-component');
-        replace(this.el, this.anchor);
-        // remove is attribute.
-        // this is removed during compilation, but because compilation is
-        // cached, when the component is used elsewhere this attribute
-        // will remain at link time.
-        this.el.removeAttribute('is');
-        this.el.removeAttribute(':is');
-        // remove ref, same as above
-        if (this.descriptor.ref) {
-          this.el.removeAttribute('v-ref:' + hyphenate(this.descriptor.ref));
-        }
-        // if static, build right now.
-        if (this.literal) {
-          this.setComponent(this.expression);
-        }
-      } else {
-        'development' !== 'production' && warn('cannot mount component "' + this.expression + '" ' + 'on already mounted element: ' + this.el);
-      }
-    },
-
-    /**
-     * Public update, called by the watcher in the dynamic
-     * literal scenario, e.g. <component :is="view">
-     */
-
-    update: function update(value) {
-      if (!this.literal) {
-        this.setComponent(value);
-      }
-    },
-
-    /**
-     * Switch dynamic components. May resolve the component
-     * asynchronously, and perform transition based on
-     * specified transition mode. Accepts a few additional
-     * arguments specifically for vue-router.
-     *
-     * The callback is called when the full transition is
-     * finished.
-     *
-     * @param {String} value
-     * @param {Function} [cb]
-     */
-
-    setComponent: function setComponent(value, cb) {
-      this.invalidatePending();
-      if (!value) {
-        // just remove current
-        this.unbuild(true);
-        this.remove(this.childVM, cb);
-        this.childVM = null;
-      } else {
-        var self = this;
-        this.resolveComponent(value, function () {
-          self.mountComponent(cb);
-        });
-      }
-    },
-
-    /**
-     * Resolve the component constructor to use when creating
-     * the child vm.
-     *
-     * @param {String|Function} value
-     * @param {Function} cb
-     */
-
-    resolveComponent: function resolveComponent(value, cb) {
-      var self = this;
-      this.pendingComponentCb = cancellable(function (Component) {
-        self.ComponentName = Component.options.name || (typeof value === 'string' ? value : null);
-        self.Component = Component;
-        cb();
-      });
-      this.vm._resolveComponent(value, this.pendingComponentCb);
-    },
-
-    /**
-     * Create a new instance using the current constructor and
-     * replace the existing instance. This method doesn't care
-     * whether the new component and the old one are actually
-     * the same.
-     *
-     * @param {Function} [cb]
-     */
-
-    mountComponent: function mountComponent(cb) {
-      // actual mount
-      this.unbuild(true);
-      var self = this;
-      var activateHooks = this.Component.options.activate;
-      var cached = this.getCached();
-      var newComponent = this.build();
-      if (activateHooks && !cached) {
-        this.waitingFor = newComponent;
-        callActivateHooks(activateHooks, newComponent, function () {
-          if (self.waitingFor !== newComponent) {
-            return;
-          }
-          self.waitingFor = null;
-          self.transition(newComponent, cb);
-        });
-      } else {
-        // update ref for kept-alive component
-        if (cached) {
-          newComponent._updateRef();
-        }
-        this.transition(newComponent, cb);
-      }
-    },
-
-    /**
-     * When the component changes or unbinds before an async
-     * constructor is resolved, we need to invalidate its
-     * pending callback.
-     */
-
-    invalidatePending: function invalidatePending() {
-      if (this.pendingComponentCb) {
-        this.pendingComponentCb.cancel();
-        this.pendingComponentCb = null;
-      }
-    },
-
-    /**
-     * Instantiate/insert a new child vm.
-     * If keep alive and has cached instance, insert that
-     * instance; otherwise build a new one and cache it.
-     *
-     * @param {Object} [extraOptions]
-     * @return {Vue} - the created instance
-     */
-
-    build: function build(extraOptions) {
-      var cached = this.getCached();
-      if (cached) {
-        return cached;
-      }
-      if (this.Component) {
-        // default options
-        var options = {
-          name: this.ComponentName,
-          el: cloneNode(this.el),
-          template: this.inlineTemplate,
-          // make sure to add the child with correct parent
-          // if this is a transcluded component, its parent
-          // should be the transclusion host.
-          parent: this._host || this.vm,
-          // if no inline-template, then the compiled
-          // linker can be cached for better performance.
-          _linkerCachable: !this.inlineTemplate,
-          _ref: this.descriptor.ref,
-          _asComponent: true,
-          _isRouterView: this._isRouterView,
-          // if this is a transcluded component, context
-          // will be the common parent vm of this instance
-          // and its host.
-          _context: this.vm,
-          // if this is inside an inline v-for, the scope
-          // will be the intermediate scope created for this
-          // repeat fragment. this is used for linking props
-          // and container directives.
-          _scope: this._scope,
-          // pass in the owner fragment of this component.
-          // this is necessary so that the fragment can keep
-          // track of its contained components in order to
-          // call attach/detach hooks for them.
-          _frag: this._frag
-        };
-        // extra options
-        // in 1.0.0 this is used by vue-router only
-        /* istanbul ignore if */
-        if (extraOptions) {
-          extend(options, extraOptions);
-        }
-        var child = new this.Component(options);
-        if (this.keepAlive) {
-          this.cache[this.Component.cid] = child;
-        }
-        /* istanbul ignore if */
-        if ('development' !== 'production' && this.el.hasAttribute('transition') && child._isFragment) {
-          warn('Transitions will not work on a fragment instance. ' + 'Template: ' + child.$options.template, child);
-        }
-        return child;
-      }
-    },
-
-    /**
-     * Try to get a cached instance of the current component.
-     *
-     * @return {Vue|undefined}
-     */
-
-    getCached: function getCached() {
-      return this.keepAlive && this.cache[this.Component.cid];
-    },
-
-    /**
-     * Teardown the current child, but defers cleanup so
-     * that we can separate the destroy and removal steps.
-     *
-     * @param {Boolean} defer
-     */
-
-    unbuild: function unbuild(defer) {
-      if (this.waitingFor) {
-        if (!this.keepAlive) {
-          this.waitingFor.$destroy();
-        }
-        this.waitingFor = null;
-      }
-      var child = this.childVM;
-      if (!child || this.keepAlive) {
-        if (child) {
-          // remove ref
-          child._inactive = true;
-          child._updateRef(true);
-        }
-        return;
-      }
-      // the sole purpose of `deferCleanup` is so that we can
-      // "deactivate" the vm right now and perform DOM removal
-      // later.
-      child.$destroy(false, defer);
-    },
-
-    /**
-     * Remove current destroyed child and manually do
-     * the cleanup after removal.
-     *
-     * @param {Function} cb
-     */
-
-    remove: function remove(child, cb) {
-      var keepAlive = this.keepAlive;
-      if (child) {
-        // we may have a component switch when a previous
-        // component is still being transitioned out.
-        // we want to trigger only one lastest insertion cb
-        // when the existing transition finishes. (#1119)
-        this.pendingRemovals++;
-        this.pendingRemovalCb = cb;
-        var self = this;
-        child.$remove(function () {
-          self.pendingRemovals--;
-          if (!keepAlive) child._cleanup();
-          if (!self.pendingRemovals && self.pendingRemovalCb) {
-            self.pendingRemovalCb();
-            self.pendingRemovalCb = null;
-          }
-        });
-      } else if (cb) {
-        cb();
-      }
-    },
-
-    /**
-     * Actually swap the components, depending on the
-     * transition mode. Defaults to simultaneous.
-     *
-     * @param {Vue} target
-     * @param {Function} [cb]
-     */
-
-    transition: function transition(target, cb) {
-      var self = this;
-      var current = this.childVM;
-      // for devtool inspection
-      if (current) current._inactive = true;
-      target._inactive = false;
-      this.childVM = target;
-      switch (self.params.transitionMode) {
-        case 'in-out':
-          target.$before(self.anchor, function () {
-            self.remove(current, cb);
-          });
-          break;
-        case 'out-in':
-          self.remove(current, function () {
-            target.$before(self.anchor, cb);
-          });
-          break;
-        default:
-          self.remove(current);
-          target.$before(self.anchor, cb);
-      }
-    },
-
-    /**
-     * Unbind.
-     */
-
-    unbind: function unbind() {
-      this.invalidatePending();
-      // Do not defer cleanup when unbinding
-      this.unbuild();
-      // destroy all keep-alive cached instances
-      if (this.cache) {
-        for (var key in this.cache) {
-          this.cache[key].$destroy();
-        }
-        this.cache = null;
-      }
-    }
-  };
-
-  /**
-   * Call activate hooks in order (asynchronous)
-   *
-   * @param {Array} hooks
-   * @param {Vue} vm
-   * @param {Function} cb
-   */
-
-  function callActivateHooks(hooks, vm, cb) {
-    var total = hooks.length;
-    var called = 0;
-    hooks[0].call(vm, next);
-    function next() {
-      if (++called >= total) {
-        cb();
-      } else {
-        hooks[called].call(vm, next);
-      }
-    }
-  }
-
-  var propBindingModes = config._propBindingModes;
-  var empty = {};
-
-  // regexes
-  var identRE$1 = /^[$_a-zA-Z]+[\w$]*$/;
-  var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/;
-
-  /**
-   * Compile props on a root element and return
-   * a props link function.
-   *
-   * @param {Element|DocumentFragment} el
-   * @param {Array} propOptions
-   * @param {Vue} vm
-   * @return {Function} propsLinkFn
-   */
-
-  function compileProps(el, propOptions, vm) {
-    var props = [];
-    var names = Object.keys(propOptions);
-    var i = names.length;
-    var options, name, attr, value, path, parsed, prop;
-    while (i--) {
-      name = names[i];
-      options = propOptions[name] || empty;
-
-      if ('development' !== 'production' && name === '$data') {
-        warn('Do not use $data as prop.', vm);
-        continue;
-      }
-
-      // props could contain dashes, which will be
-      // interpreted as minus calculations by the parser
-      // so we need to camelize the path here
-      path = camelize(name);
-      if (!identRE$1.test(path)) {
-        'development' !== 'production' && warn('Invalid prop key: "' + name + '". Prop keys ' + 'must be valid identifiers.', vm);
-        continue;
-      }
-
-      prop = {
-        name: name,
-        path: path,
-        options: options,
-        mode: propBindingModes.ONE_WAY,
-        raw: null
-      };
-
-      attr = hyphenate(name);
-      // first check dynamic version
-      if ((value = getBindAttr(el, attr)) === null) {
-        if ((value = getBindAttr(el, attr + '.sync')) !== null) {
-          prop.mode = propBindingModes.TWO_WAY;
-        } else if ((value = getBindAttr(el, attr + '.once')) !== null) {
-          prop.mode = propBindingModes.ONE_TIME;
-        }
-      }
-      if (value !== null) {
-        // has dynamic binding!
-        prop.raw = value;
-        parsed = parseDirective(value);
-        value = parsed.expression;
-        prop.filters = parsed.filters;
-        // check binding type
-        if (isLiteral(value) && !parsed.filters) {
-          // for expressions containing literal numbers and
-          // booleans, there's no need to setup a prop binding,
-          // so we can optimize them as a one-time set.
-          prop.optimizedLiteral = true;
-        } else {
-          prop.dynamic = true;
-          // check non-settable path for two-way bindings
-          if ('development' !== 'production' && prop.mode === propBindingModes.TWO_WAY && !settablePathRE.test(value)) {
-            prop.mode = propBindingModes.ONE_WAY;
-            warn('Cannot bind two-way prop with non-settable ' + 'parent path: ' + value, vm);
-          }
-        }
-        prop.parentPath = value;
-
-        // warn required two-way
-        if ('development' !== 'production' && options.twoWay && prop.mode !== propBindingModes.TWO_WAY) {
-          warn('Prop "' + name + '" expects a two-way binding type.', vm);
-        }
-      } else if ((value = getAttr(el, attr)) !== null) {
-        // has literal binding!
-        prop.raw = value;
-      } else if ('development' !== 'production') {
-        // check possible camelCase prop usage
-        var lowerCaseName = path.toLowerCase();
-        value = /[A-Z\-]/.test(name) && (el.getAttribute(lowerCaseName) || el.getAttribute(':' + lowerCaseName) || el.getAttribute('v-bind:' + lowerCaseName) || el.getAttribute(':' + lowerCaseName + '.once') || el.getAttribute('v-bind:' + lowerCaseName + '.once') || el.getAttribute(':' + lowerCaseName + '.sync') || el.getAttribute('v-bind:' + lowerCaseName + '.sync'));
-        if (value) {
-          warn('Possible usage error for prop `' + lowerCaseName + '` - ' + 'did you mean `' + attr + '`? HTML is case-insensitive, remember to use ' + 'kebab-case for props in templates.', vm);
-        } else if (options.required) {
-          // warn missing required
-          warn('Missing required prop: ' + name, vm);
-        }
-      }
-      // push prop
-      props.push(prop);
-    }
-    return makePropsLinkFn(props);
-  }
-
-  /**
-   * Build a function that applies props to a vm.
-   *
-   * @param {Array} props
-   * @return {Function} propsLinkFn
-   */
-
-  function makePropsLinkFn(props) {
-    return function propsLinkFn(vm, scope) {
-      // store resolved props info
-      vm._props = {};
-      var inlineProps = vm.$options.propsData;
-      var i = props.length;
-      var prop, path, options, value, raw;
-      while (i--) {
-        prop = props[i];
-        raw = prop.raw;
-        path = prop.path;
-        options = prop.options;
-        vm._props[path] = prop;
-        if (inlineProps && hasOwn(inlineProps, path)) {
-          initProp(vm, prop, inlineProps[path]);
-        }if (raw === null) {
-          // initialize absent prop
-          initProp(vm, prop, undefined);
-        } else if (prop.dynamic) {
-          // dynamic prop
-          if (prop.mode === propBindingModes.ONE_TIME) {
-            // one time binding
-            value = (scope || vm._context || vm).$get(prop.parentPath);
-            initProp(vm, prop, value);
-          } else {
-            if (vm._context) {
-              // dynamic binding
-              vm._bindDir({
-                name: 'prop',
-                def: propDef,
-                prop: prop
-              }, null, null, scope); // el, host, scope
-            } else {
-                // root instance
-                initProp(vm, prop, vm.$get(prop.parentPath));
-              }
-          }
-        } else if (prop.optimizedLiteral) {
-          // optimized literal, cast it and just set once
-          var stripped = stripQuotes(raw);
-          value = stripped === raw ? toBoolean(toNumber(raw)) : stripped;
-          initProp(vm, prop, value);
-        } else {
-          // string literal, but we need to cater for
-          // Boolean props with no value, or with same
-          // literal value (e.g. disabled="disabled")
-          // see https://github.com/vuejs/vue-loader/issues/182
-          value = options.type === Boolean && (raw === '' || raw === hyphenate(prop.name)) ? true : raw;
-          initProp(vm, prop, value);
-        }
-      }
-    };
-  }
-
-  /**
-   * Process a prop with a rawValue, applying necessary coersions,
-   * default values & assertions and call the given callback with
-   * processed value.
-   *
-   * @param {Vue} vm
-   * @param {Object} prop
-   * @param {*} rawValue
-   * @param {Function} fn
-   */
-
-  function processPropValue(vm, prop, rawValue, fn) {
-    var isSimple = prop.dynamic && isSimplePath(prop.parentPath);
-    var value = rawValue;
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop);
-    }
-    value = coerceProp(prop, value, vm);
-    var coerced = value !== rawValue;
-    if (!assertProp(prop, value, vm)) {
-      value = undefined;
-    }
-    if (isSimple && !coerced) {
-      withoutConversion(function () {
-        fn(value);
-      });
-    } else {
-      fn(value);
-    }
-  }
-
-  /**
-   * Set a prop's initial value on a vm and its data object.
-   *
-   * @param {Vue} vm
-   * @param {Object} prop
-   * @param {*} value
-   */
-
-  function initProp(vm, prop, value) {
-    processPropValue(vm, prop, value, function (value) {
-      defineReactive(vm, prop.path, value);
-    });
-  }
-
-  /**
-   * Update a prop's value on a vm.
-   *
-   * @param {Vue} vm
-   * @param {Object} prop
-   * @param {*} value
-   */
-
-  function updateProp(vm, prop, value) {
-    processPropValue(vm, prop, value, function (value) {
-      vm[prop.path] = value;
-    });
-  }
-
-  /**
-   * Get the default value of a prop.
-   *
-   * @param {Vue} vm
-   * @param {Object} prop
-   * @return {*}
-   */
-
-  function getPropDefaultValue(vm, prop) {
-    // no default, return undefined
-    var options = prop.options;
-    if (!hasOwn(options, 'default')) {
-      // absent boolean value defaults to false
-      return options.type === Boolean ? false : undefined;
-    }
-    var def = options['default'];
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      'development' !== 'production' && warn('Invalid default value for prop "' + prop.name + '": ' + 'Props with type Object/Array must use a factory function ' + 'to return the default value.', vm);
-    }
-    // call factory function for non-Function types
-    return typeof def === 'function' && options.type !== Function ? def.call(vm) : def;
-  }
-
-  /**
-   * Assert whether a prop is valid.
-   *
-   * @param {Object} prop
-   * @param {*} value
-   * @param {Vue} vm
-   */
-
-  function assertProp(prop, value, vm) {
-    if (!prop.options.required && ( // non-required
-    prop.raw === null || // abscent
-    value == null) // null or undefined
-    ) {
-        return true;
-      }
-    var options = prop.options;
-    var type = options.type;
-    var valid = !type;
-    var expectedTypes = [];
-    if (type) {
-      if (!isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i]);
-        expectedTypes.push(assertedType.expectedType);
-        valid = assertedType.valid;
-      }
-    }
-    if (!valid) {
-      if ('development' !== 'production') {
-        warn('Invalid prop: type check failed for prop "' + prop.name + '".' + ' Expected ' + expectedTypes.map(formatType).join(', ') + ', got ' + formatValue(value) + '.', vm);
-      }
-      return false;
-    }
-    var validator = options.validator;
-    if (validator) {
-      if (!validator(value)) {
-        'development' !== 'production' && warn('Invalid prop: custom validator check failed for prop "' + prop.name + '".', vm);
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Force parsing value with coerce option.
-   *
-   * @param {*} value
-   * @param {Object} options
-   * @return {*}
-   */
-
-  function coerceProp(prop, value, vm) {
-    var coerce = prop.options.coerce;
-    if (!coerce) {
-      return value;
-    }
-    if (typeof coerce === 'function') {
-      return coerce(value);
-    } else {
-      'development' !== 'production' && warn('Invalid coerce for prop "' + prop.name + '": expected function, got ' + typeof coerce + '.', vm);
-      return value;
-    }
-  }
-
-  /**
-   * Assert the type of a value
-   *
-   * @param {*} value
-   * @param {Function} type
-   * @return {Object}
-   */
-
-  function assertType(value, type) {
-    var valid;
-    var expectedType;
-    if (type === String) {
-      expectedType = 'string';
-      valid = typeof value === expectedType;
-    } else if (type === Number) {
-      expectedType = 'number';
-      valid = typeof value === expectedType;
-    } else if (type === Boolean) {
-      expectedType = 'boolean';
-      valid = typeof value === expectedType;
-    } else if (type === Function) {
-      expectedType = 'function';
-      valid = typeof value === expectedType;
-    } else if (type === Object) {
-      expectedType = 'object';
-      valid = isPlainObject(value);
-    } else if (type === Array) {
-      expectedType = 'array';
-      valid = isArray(value);
-    } else {
-      valid = value instanceof type;
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType
-    };
-  }
-
-  /**
-   * Format type for output
-   *
-   * @param {String} type
-   * @return {String}
-   */
-
-  function formatType(type) {
-    return type ? type.charAt(0).toUpperCase() + type.slice(1) : 'custom type';
-  }
-
-  /**
-   * Format value
-   *
-   * @param {*} value
-   * @return {String}
-   */
-
-  function formatValue(val) {
-    return Object.prototype.toString.call(val).slice(8, -1);
-  }
-
-  var bindingModes = config._propBindingModes;
-
-  var propDef = {
-
-    bind: function bind() {
-      var child = this.vm;
-      var parent = child._context;
-      // passed in from compiler directly
-      var prop = this.descriptor.prop;
-      var childKey = prop.path;
-      var parentKey = prop.parentPath;
-      var twoWay = prop.mode === bindingModes.TWO_WAY;
-
-      var parentWatcher = this.parentWatcher = new Watcher(parent, parentKey, function (val) {
-        updateProp(child, prop, val);
-      }, {
-        twoWay: twoWay,
-        filters: prop.filters,
-        // important: props need to be observed on the
-        // v-for scope if present
-        scope: this._scope
-      });
-
-      // set the child initial value.
-      initProp(child, prop, parentWatcher.value);
-
-      // setup two-way binding
-      if (twoWay) {
-        // important: defer the child watcher creation until
-        // the created hook (after data observation)
-        var self = this;
-        child.$once('pre-hook:created', function () {
-          self.childWatcher = new Watcher(child, childKey, function (val) {
-            parentWatcher.set(val);
-          }, {
-            // ensure sync upward before parent sync down.
-            // this is necessary in cases e.g. the child
-            // mutates a prop array, then replaces it. (#1683)
-            sync: true
-          });
-        });
-      }
-    },
-
-    unbind: function unbind() {
-      this.parentWatcher.teardown();
-      if (this.childWatcher) {
-        this.childWatcher.teardown();
-      }
-    }
-  };
-
-  var queue$1 = [];
-  var queued = false;
-
-  /**
-   * Push a job into the queue.
-   *
-   * @param {Function} job
-   */
-
-  function pushJob(job) {
-    queue$1.push(job);
-    if (!queued) {
-      queued = true;
-      nextTick(flush);
-    }
-  }
-
-  /**
-   * Flush the queue, and do one forced reflow before
-   * triggering transitions.
-   */
-
-  function flush() {
-    // Force layout
-    var f = document.documentElement.offsetHeight;
-    for (var i = 0; i < queue$1.length; i++) {
-      queue$1[i]();
-    }
-    queue$1 = [];
-    queued = false;
-    // dummy return, so js linters don't complain about
-    // unused variable f
-    return f;
-  }
-
-  var TYPE_TRANSITION = 'transition';
-  var TYPE_ANIMATION = 'animation';
-  var transDurationProp = transitionProp + 'Duration';
-  var animDurationProp = animationProp + 'Duration';
-
-  /**
-   * If a just-entered element is applied the
-   * leave class while its enter transition hasn't started yet,
-   * and the transitioned property has the same value for both
-   * enter/leave, then the leave transition will be skipped and
-   * the transitionend event never fires. This function ensures
-   * its callback to be called after a transition has started
-   * by waiting for double raf.
-   *
-   * It falls back to setTimeout on devices that support CSS
-   * transitions but not raf (e.g. Android 4.2 browser) - since
-   * these environments are usually slow, we are giving it a
-   * relatively large timeout.
-   */
-
-  var raf = inBrowser && window.requestAnimationFrame;
-  var waitForTransitionStart = raf
-  /* istanbul ignore next */
-  ? function (fn) {
-    raf(function () {
-      raf(fn);
-    });
-  } : function (fn) {
-    setTimeout(fn, 50);
-  };
-
-  /**
-   * A Transition object that encapsulates the state and logic
-   * of the transition.
-   *
-   * @param {Element} el
-   * @param {String} id
-   * @param {Object} hooks
-   * @param {Vue} vm
-   */
-  function Transition(el, id, hooks, vm) {
-    this.id = id;
-    this.el = el;
-    this.enterClass = hooks && hooks.enterClass || id + '-enter';
-    this.leaveClass = hooks && hooks.leaveClass || id + '-leave';
-    this.hooks = hooks;
-    this.vm = vm;
-    // async state
-    this.pendingCssEvent = this.pendingCssCb = this.cancel = this.pendingJsCb = this.op = this.cb = null;
-    this.justEntered = false;
-    this.entered = this.left = false;
-    this.typeCache = {};
-    // check css transition type
-    this.type = hooks && hooks.type;
-    /* istanbul ignore if */
-    if ('development' !== 'production') {
-      if (this.type && this.type !== TYPE_TRANSITION && this.type !== TYPE_ANIMATION) {
-        warn('invalid CSS transition type for transition="' + this.id + '": ' + this.type, vm);
-      }
-    }
-    // bind
-    var self = this;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone'].forEach(function (m) {
-      self[m] = bind(self[m], self);
-    });
-  }
-
-  var p$1 = Transition.prototype;
-
-  /**
-   * Start an entering transition.
-   *
-   * 1. enter transition triggered
-   * 2. call beforeEnter hook
-   * 3. add enter class
-   * 4. insert/show element
-   * 5. call enter hook (with possible explicit js callback)
-   * 6. reflow
-   * 7. based on transition type:
-   *    - transition:
-   *        remove class now, wait for transitionend,
-   *        then done if there's no explicit js callback.
-   *    - animation:
-   *        wait for animationend, remove class,
-   *        then done if there's no explicit js callback.
-   *    - no css transition:
-   *        done now if there's no explicit js callback.
-   * 8. wait for either done or js callback, then call
-   *    afterEnter hook.
-   *
-   * @param {Function} op - insert/show the element
-   * @param {Function} [cb]
-   */
-
-  p$1.enter = function (op, cb) {
-    this.cancelPending();
-    this.callHook('beforeEnter');
-    this.cb = cb;
-    addClass(this.el, this.enterClass);
-    op();
-    this.entered = false;
-    this.callHookWithCb('enter');
-    if (this.entered) {
-      return; // user called done synchronously.
-    }
-    this.cancel = this.hooks && this.hooks.enterCancelled;
-    pushJob(this.enterNextTick);
-  };
-
-  /**
-   * The "nextTick" phase of an entering transition, which is
-   * to be pushed into a queue and executed after a reflow so
-   * that removing the class can trigger a CSS transition.
-   */
-
-  p$1.enterNextTick = function () {
-    var _this = this;
-
-    // prevent transition skipping
-    this.justEntered = true;
-    waitForTransitionStart(function () {
-      _this.justEntered = false;
-    });
-    var enterDone = this.enterDone;
-    var type = this.getCssTransitionType(this.enterClass);
-    if (!this.pendingJsCb) {
-      if (type === TYPE_TRANSITION) {
-        // trigger transition by removing enter class now
-        removeClass(this.el, this.enterClass);
-        this.setupCssCb(transitionEndEvent, enterDone);
-      } else if (type === TYPE_ANIMATION) {
-        this.setupCssCb(animationEndEvent, enterDone);
-      } else {
-        enterDone();
-      }
-    } else if (type === TYPE_TRANSITION) {
-      removeClass(this.el, this.enterClass);
-    }
-  };
-
-  /**
-   * The "cleanup" phase of an entering transition.
-   */
-
-  p$1.enterDone = function () {
-    this.entered = true;
-    this.cancel = this.pendingJsCb = null;
-    removeClass(this.el, this.enterClass);
-    this.callHook('afterEnter');
-    if (this.cb) this.cb();
-  };
-
-  /**
-   * Start a leaving transition.
-   *
-   * 1. leave transition triggered.
-   * 2. call beforeLeave hook
-   * 3. add leave class (trigger css transition)
-   * 4. call leave hook (with possible explicit js callback)
-   * 5. reflow if no explicit js callback is provided
-   * 6. based on transition type:
-   *    - transition or animation:
-   *        wait for end event, remove class, then done if
-   *        there's no explicit js callback.
-   *    - no css transition:
-   *        done if there's no explicit js callback.
-   * 7. wait for either done or js callback, then call
-   *    afterLeave hook.
-   *
-   * @param {Function} op - remove/hide the element
-   * @param {Function} [cb]
-   */
-
-  p$1.leave = function (op, cb) {
-    this.cancelPending();
-    this.callHook('beforeLeave');
-    this.op = op;
-    this.cb = cb;
-    addClass(this.el, this.leaveClass);
-    this.left = false;
-    this.callHookWithCb('leave');
-    if (this.left) {
-      return; // user called done synchronously.
-    }
-    this.cancel = this.hooks && this.hooks.leaveCancelled;
-    // only need to handle leaveDone if
-    // 1. the transition is already done (synchronously called
-    //    by the user, which causes this.op set to null)
-    // 2. there's no explicit js callback
-    if (this.op && !this.pendingJsCb) {
-      // if a CSS transition leaves immediately after enter,
-      // the transitionend event never fires. therefore we
-      // detect such cases and end the leave immediately.
-      if (this.justEntered) {
-        this.leaveDone();
-      } else {
-        pushJob(this.leaveNextTick);
-      }
-    }
-  };
-
-  /**
-   * The "nextTick" phase of a leaving transition.
-   */
-
-  p$1.leaveNextTick = function () {
-    var type = this.getCssTransitionType(this.leaveClass);
-    if (type) {
-      var event = type === TYPE_TRANSITION ? transitionEndEvent : animationEndEvent;
-      this.setupCssCb(event, this.leaveDone);
-    } else {
-      this.leaveDone();
-    }
-  };
-
-  /**
-   * The "cleanup" phase of a leaving transition.
-   */
-
-  p$1.leaveDone = function () {
-    this.left = true;
-    this.cancel = this.pendingJsCb = null;
-    this.op();
-    removeClass(this.el, this.leaveClass);
-    this.callHook('afterLeave');
-    if (this.cb) this.cb();
-    this.op = null;
-  };
-
-  /**
-   * Cancel any pending callbacks from a previously running
-   * but not finished transition.
-   */
-
-  p$1.cancelPending = function () {
-    this.op = this.cb = null;
-    var hasPending = false;
-    if (this.pendingCssCb) {
-      hasPending = true;
-      off(this.el, this.pendingCssEvent, this.pendingCssCb);
-      this.pendingCssEvent = this.pendingCssCb = null;
-    }
-    if (this.pendingJsCb) {
-      hasPending = true;
-      this.pendingJsCb.cancel();
-      this.pendingJsCb = null;
-    }
-    if (hasPending) {
-      removeClass(this.el, this.enterClass);
-      removeClass(this.el, this.leaveClass);
-    }
-    if (this.cancel) {
-      this.cancel.call(this.vm, this.el);
-      this.cancel = null;
-    }
-  };
-
-  /**
-   * Call a user-provided synchronous hook function.
-   *
-   * @param {String} type
-   */
-
-  p$1.callHook = function (type) {
-    if (this.hooks && this.hooks[type]) {
-      this.hooks[type].call(this.vm, this.el);
-    }
-  };
-
-  /**
-   * Call a user-provided, potentially-async hook function.
-   * We check for the length of arguments to see if the hook
-   * expects a `done` callback. If true, the transition's end
-   * will be determined by when the user calls that callback;
-   * otherwise, the end is determined by the CSS transition or
-   * animation.
-   *
-   * @param {String} type
-   */
-
-  p$1.callHookWithCb = function (type) {
-    var hook = this.hooks && this.hooks[type];
-    if (hook) {
-      if (hook.length > 1) {
-        this.pendingJsCb = cancellable(this[type + 'Done']);
-      }
-      hook.call(this.vm, this.el, this.pendingJsCb);
-    }
-  };
-
-  /**
-   * Get an element's transition type based on the
-   * calculated styles.
-   *
-   * @param {String} className
-   * @return {Number}
-   */
-
-  p$1.getCssTransitionType = function (className) {
-    /* istanbul ignore if */
-    if (!transitionEndEvent ||
-    // skip CSS transitions if page is not visible -
-    // this solves the issue of transitionend events not
-    // firing until the page is visible again.
-    // pageVisibility API is supported in IE10+, same as
-    // CSS transitions.
-    document.hidden ||
-    // explicit js-only transition
-    this.hooks && this.hooks.css === false ||
-    // element is hidden
-    isHidden(this.el)) {
-      return;
-    }
-    var type = this.type || this.typeCache[className];
-    if (type) return type;
-    var inlineStyles = this.el.style;
-    var computedStyles = window.getComputedStyle(this.el);
-    var transDuration = inlineStyles[transDurationProp] || computedStyles[transDurationProp];
-    if (transDuration && transDuration !== '0s') {
-      type = TYPE_TRANSITION;
-    } else {
-      var animDuration = inlineStyles[animDurationProp] || computedStyles[animDurationProp];
-      if (animDuration && animDuration !== '0s') {
-        type = TYPE_ANIMATION;
-      }
-    }
-    if (type) {
-      this.typeCache[className] = type;
-    }
-    return type;
-  };
-
-  /**
-   * Setup a CSS transitionend/animationend callback.
-   *
-   * @param {String} event
-   * @param {Function} cb
-   */
-
-  p$1.setupCssCb = function (event, cb) {
-    this.pendingCssEvent = event;
-    var self = this;
-    var el = this.el;
-    var onEnd = this.pendingCssCb = function (e) {
-      if (e.target === el) {
-        off(el, event, onEnd);
-        self.pendingCssEvent = self.pendingCssCb = null;
-        if (!self.pendingJsCb && cb) {
-          cb();
-        }
-      }
-    };
-    on(el, event, onEnd);
-  };
-
-  /**
-   * Check if an element is hidden - in that case we can just
-   * skip the transition alltogether.
-   *
-   * @param {Element} el
-   * @return {Boolean}
-   */
-
-  function isHidden(el) {
-    if (/svg$/.test(el.namespaceURI)) {
-      // SVG elements do not have offset(Width|Height)
-      // so we need to check the client rect
-      var rect = el.getBoundingClientRect();
-      return !(rect.width || rect.height);
-    } else {
-      return !(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
-    }
-  }
-
-  var transition$1 = {
-
-    priority: TRANSITION,
-
-    update: function update(id, oldId) {
-      var el = this.el;
-      // resolve on owner vm
-      var hooks = resolveAsset(this.vm.$options, 'transitions', id);
-      id = id || 'v';
-      oldId = oldId || 'v';
-      el.__v_trans = new Transition(el, id, hooks, this.vm);
-      removeClass(el, oldId + '-transition');
-      addClass(el, id + '-transition');
-    }
-  };
-
-  var internalDirectives = {
-    style: style,
-    'class': vClass,
-    component: component,
-    prop: propDef,
-    transition: transition$1
-  };
-
-  // special binding prefixes
-  var bindRE = /^v-bind:|^:/;
-  var onRE = /^v-on:|^@/;
-  var dirAttrRE = /^v-([^:]+)(?:$|:(.*)$)/;
-  var modifierRE = /\.[^\.]+/g;
-  var transitionRE = /^(v-bind:|:)?transition$/;
-
-  // default directive priority
-  var DEFAULT_PRIORITY = 1000;
-  var DEFAULT_TERMINAL_PRIORITY = 2000;
-
-  /**
-   * Compile a template and return a reusable composite link
-   * function, which recursively contains more link functions
-   * inside. This top level compile function would normally
-   * be called on instance root nodes, but can also be used
-   * for partial compilation if the partial argument is true.
-   *
-   * The returned composite link function, when called, will
-   * return an unlink function that tearsdown all directives
-   * created during the linking phase.
-   *
-   * @param {Element|DocumentFragment} el
-   * @param {Object} options
-   * @param {Boolean} partial
-   * @return {Function}
-   */
-
-  function compile(el, options, partial) {
-    // link function for the node itself.
-    var nodeLinkFn = partial || !options._asComponent ? compileNode(el, options) : null;
-    // link function for the childNodes
-    var childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && !isScript(el) && el.hasChildNodes() ? compileNodeList(el.childNodes, options) : null;
-
-    /**
-     * A composite linker function to be called on a already
-     * compiled piece of DOM, which instantiates all directive
-     * instances.
-     *
-     * @param {Vue} vm
-     * @param {Element|DocumentFragment} el
-     * @param {Vue} [host] - host vm of transcluded content
-     * @param {Object} [scope] - v-for scope
-     * @param {Fragment} [frag] - link context fragment
-     * @return {Function|undefined}
-     */
-
-    return function compositeLinkFn(vm, el, host, scope, frag) {
-      // cache childNodes before linking parent, fix #657
-      var childNodes = toArray(el.childNodes);
-      // link
-      var dirs = linkAndCapture(function compositeLinkCapturer() {
-        if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag);
-        if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag);
-      }, vm);
-      return makeUnlinkFn(vm, dirs);
-    };
-  }
-
-  /**
-   * Apply a linker to a vm/element pair and capture the
-   * directives created during the process.
-   *
-   * @param {Function} linker
-   * @param {Vue} vm
-   */
-
-  function linkAndCapture(linker, vm) {
-    /* istanbul ignore if */
-    if ('development' === 'production') {}
-    var originalDirCount = vm._directives.length;
-    linker();
-    var dirs = vm._directives.slice(originalDirCount);
-    dirs.sort(directiveComparator);
-    for (var i = 0, l = dirs.length; i < l; i++) {
-      dirs[i]._bind();
-    }
-    return dirs;
-  }
-
-  /**
-   * Directive priority sort comparator
-   *
-   * @param {Object} a
-   * @param {Object} b
-   */
-
-  function directiveComparator(a, b) {
-    a = a.descriptor.def.priority || DEFAULT_PRIORITY;
-    b = b.descriptor.def.priority || DEFAULT_PRIORITY;
-    return a > b ? -1 : a === b ? 0 : 1;
-  }
-
-  /**
-   * Linker functions return an unlink function that
-   * tearsdown all directives instances generated during
-   * the process.
-   *
-   * We create unlink functions with only the necessary
-   * information to avoid retaining additional closures.
-   *
-   * @param {Vue} vm
-   * @param {Array} dirs
-   * @param {Vue} [context]
-   * @param {Array} [contextDirs]
-   * @return {Function}
-   */
-
-  function makeUnlinkFn(vm, dirs, context, contextDirs) {
-    function unlink(destroying) {
-      teardownDirs(vm, dirs, destroying);
-      if (context && contextDirs) {
-        teardownDirs(context, contextDirs);
-      }
-    }
-    // expose linked directives
-    unlink.dirs = dirs;
-    return unlink;
-  }
-
-  /**
-   * Teardown partial linked directives.
-   *
-   * @param {Vue} vm
-   * @param {Array} dirs
-   * @param {Boolean} destroying
-   */
-
-  function teardownDirs(vm, dirs, destroying) {
-    var i = dirs.length;
-    while (i--) {
-      dirs[i]._teardown();
-      if ('development' !== 'production' && !destroying) {
-        vm._directives.$remove(dirs[i]);
-      }
-    }
-  }
-
-  /**
-   * Compile link props on an instance.
-   *
-   * @param {Vue} vm
-   * @param {Element} el
-   * @param {Object} props
-   * @param {Object} [scope]
-   * @return {Function}
-   */
-
-  function compileAndLinkProps(vm, el, props, scope) {
-    var propsLinkFn = compileProps(el, props, vm);
-    var propDirs = linkAndCapture(function () {
-      propsLinkFn(vm, scope);
-    }, vm);
-    return makeUnlinkFn(vm, propDirs);
-  }
-
-  /**
-   * Compile the root element of an instance.
-   *
-   * 1. attrs on context container (context scope)
-   * 2. attrs on the component template root node, if
-   *    replace:true (child scope)
-   *
-   * If this is a fragment instance, we only need to compile 1.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @param {Object} contextOptions
-   * @return {Function}
-   */
-
-  function compileRoot(el, options, contextOptions) {
-    var containerAttrs = options._containerAttrs;
-    var replacerAttrs = options._replacerAttrs;
-    var contextLinkFn, replacerLinkFn;
-
-    // only need to compile other attributes for
-    // non-fragment instances
-    if (el.nodeType !== 11) {
-      // for components, container and replacer need to be
-      // compiled separately and linked in different scopes.
-      if (options._asComponent) {
-        // 2. container attributes
-        if (containerAttrs && contextOptions) {
-          contextLinkFn = compileDirectives(containerAttrs, contextOptions);
-        }
-        if (replacerAttrs) {
-          // 3. replacer attributes
-          replacerLinkFn = compileDirectives(replacerAttrs, options);
-        }
-      } else {
-        // non-component, just compile as a normal element.
-        replacerLinkFn = compileDirectives(el.attributes, options);
-      }
-    } else if ('development' !== 'production' && containerAttrs) {
-      // warn container directives for fragment instances
-      var names = containerAttrs.filter(function (attr) {
-        // allow vue-loader/vueify scoped css attributes
-        return attr.name.indexOf('_v-') < 0 &&
-        // allow event listeners
-        !onRE.test(attr.name) &&
-        // allow slots
-        attr.name !== 'slot';
-      }).map(function (attr) {
-        return '"' + attr.name + '"';
-      });
-      if (names.length) {
-        var plural = names.length > 1;
-        warn('Attribute' + (plural ? 's ' : ' ') + names.join(', ') + (plural ? ' are' : ' is') + ' ignored on component ' + '<' + options.el.tagName.toLowerCase() + '> because ' + 'the component is a fragment instance: ' + 'http://vuejs.org/guide/components.html#Fragment-Instance');
-      }
-    }
-
-    options._containerAttrs = options._replacerAttrs = null;
-    return function rootLinkFn(vm, el, scope) {
-      // link context scope dirs
-      var context = vm._context;
-      var contextDirs;
-      if (context && contextLinkFn) {
-        contextDirs = linkAndCapture(function () {
-          contextLinkFn(context, el, null, scope);
-        }, context);
-      }
-
-      // link self
-      var selfDirs = linkAndCapture(function () {
-        if (replacerLinkFn) replacerLinkFn(vm, el);
-      }, vm);
-
-      // return the unlink function that tearsdown context
-      // container directives.
-      return makeUnlinkFn(vm, selfDirs, context, contextDirs);
-    };
-  }
-
-  /**
-   * Compile a node and return a nodeLinkFn based on the
-   * node type.
-   *
-   * @param {Node} node
-   * @param {Object} options
-   * @return {Function|null}
-   */
-
-  function compileNode(node, options) {
-    var type = node.nodeType;
-    if (type === 1 && !isScript(node)) {
-      return compileElement(node, options);
-    } else if (type === 3 && node.data.trim()) {
-      return compileTextNode(node, options);
-    } else {
-      return null;
-    }
-  }
-
-  /**
-   * Compile an element and return a nodeLinkFn.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Function|null}
-   */
-
-  function compileElement(el, options) {
-    // preprocess textareas.
-    // textarea treats its text content as the initial value.
-    // just bind it as an attr directive for value.
-    if (el.tagName === 'TEXTAREA') {
-      var tokens = parseText(el.value);
-      if (tokens) {
-        el.setAttribute(':value', tokensToExp(tokens));
-        el.value = '';
-      }
-    }
-    var linkFn;
-    var hasAttrs = el.hasAttributes();
-    var attrs = hasAttrs && toArray(el.attributes);
-    // check terminal directives (for & if)
-    if (hasAttrs) {
-      linkFn = checkTerminalDirectives(el, attrs, options);
-    }
-    // check element directives
-    if (!linkFn) {
-      linkFn = checkElementDirectives(el, options);
-    }
-    // check component
-    if (!linkFn) {
-      linkFn = checkComponent(el, options);
-    }
-    // normal directives
-    if (!linkFn && hasAttrs) {
-      linkFn = compileDirectives(attrs, options);
-    }
-    return linkFn;
-  }
-
-  /**
-   * Compile a textNode and return a nodeLinkFn.
-   *
-   * @param {TextNode} node
-   * @param {Object} options
-   * @return {Function|null} textNodeLinkFn
-   */
-
-  function compileTextNode(node, options) {
-    // skip marked text nodes
-    if (node._skip) {
-      return removeText;
-    }
-
-    var tokens = parseText(node.wholeText);
-    if (!tokens) {
-      return null;
-    }
-
-    // mark adjacent text nodes as skipped,
-    // because we are using node.wholeText to compile
-    // all adjacent text nodes together. This fixes
-    // issues in IE where sometimes it splits up a single
-    // text node into multiple ones.
-    var next = node.nextSibling;
-    while (next && next.nodeType === 3) {
-      next._skip = true;
-      next = next.nextSibling;
-    }
-
-    var frag = document.createDocumentFragment();
-    var el, token;
-    for (var i = 0, l = tokens.length; i < l; i++) {
-      token = tokens[i];
-      el = token.tag ? processTextToken(token, options) : document.createTextNode(token.value);
-      frag.appendChild(el);
-    }
-    return makeTextNodeLinkFn(tokens, frag, options);
-  }
-
-  /**
-   * Linker for an skipped text node.
-   *
-   * @param {Vue} vm
-   * @param {Text} node
-   */
-
-  function removeText(vm, node) {
-    remove(node);
-  }
-
-  /**
-   * Process a single text token.
-   *
-   * @param {Object} token
-   * @param {Object} options
-   * @return {Node}
-   */
-
-  function processTextToken(token, options) {
-    var el;
-    if (token.oneTime) {
-      el = document.createTextNode(token.value);
-    } else {
-      if (token.html) {
-        el = document.createComment('v-html');
-        setTokenType('html');
-      } else {
-        // IE will clean up empty textNodes during
-        // frag.cloneNode(true), so we have to give it
-        // something here...
-        el = document.createTextNode(' ');
-        setTokenType('text');
-      }
-    }
-    function setTokenType(type) {
-      if (token.descriptor) return;
-      var parsed = parseDirective(token.value);
-      token.descriptor = {
-        name: type,
-        def: directives[type],
-        expression: parsed.expression,
-        filters: parsed.filters
-      };
-    }
-    return el;
-  }
-
-  /**
-   * Build a function that processes a textNode.
-   *
-   * @param {Array<Object>} tokens
-   * @param {DocumentFragment} frag
-   */
-
-  function makeTextNodeLinkFn(tokens, frag) {
-    return function textNodeLinkFn(vm, el, host, scope) {
-      var fragClone = frag.cloneNode(true);
-      var childNodes = toArray(fragClone.childNodes);
-      var token, value, node;
-      for (var i = 0, l = tokens.length; i < l; i++) {
-        token = tokens[i];
-        value = token.value;
-        if (token.tag) {
-          node = childNodes[i];
-          if (token.oneTime) {
-            value = (scope || vm).$eval(value);
-            if (token.html) {
-              replace(node, parseTemplate(value, true));
-            } else {
-              node.data = _toString(value);
-            }
-          } else {
-            vm._bindDir(token.descriptor, node, host, scope);
-          }
-        }
-      }
-      replace(el, fragClone);
-    };
-  }
-
-  /**
-   * Compile a node list and return a childLinkFn.
-   *
-   * @param {NodeList} nodeList
-   * @param {Object} options
-   * @return {Function|undefined}
-   */
-
-  function compileNodeList(nodeList, options) {
-    var linkFns = [];
-    var nodeLinkFn, childLinkFn, node;
-    for (var i = 0, l = nodeList.length; i < l; i++) {
-      node = nodeList[i];
-      nodeLinkFn = compileNode(node, options);
-      childLinkFn = !(nodeLinkFn && nodeLinkFn.terminal) && node.tagName !== 'SCRIPT' && node.hasChildNodes() ? compileNodeList(node.childNodes, options) : null;
-      linkFns.push(nodeLinkFn, childLinkFn);
-    }
-    return linkFns.length ? makeChildLinkFn(linkFns) : null;
-  }
-
-  /**
-   * Make a child link function for a node's childNodes.
-   *
-   * @param {Array<Function>} linkFns
-   * @return {Function} childLinkFn
-   */
-
-  function makeChildLinkFn(linkFns) {
-    return function childLinkFn(vm, nodes, host, scope, frag) {
-      var node, nodeLinkFn, childrenLinkFn;
-      for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {
-        node = nodes[n];
-        nodeLinkFn = linkFns[i++];
-        childrenLinkFn = linkFns[i++];
-        // cache childNodes before linking parent, fix #657
-        var childNodes = toArray(node.childNodes);
-        if (nodeLinkFn) {
-          nodeLinkFn(vm, node, host, scope, frag);
-        }
-        if (childrenLinkFn) {
-          childrenLinkFn(vm, childNodes, host, scope, frag);
-        }
-      }
-    };
-  }
-
-  /**
-   * Check for element directives (custom elements that should
-   * be resovled as terminal directives).
-   *
-   * @param {Element} el
-   * @param {Object} options
-   */
-
-  function checkElementDirectives(el, options) {
-    var tag = el.tagName.toLowerCase();
-    if (commonTagRE.test(tag)) {
-      return;
-    }
-    var def = resolveAsset(options, 'elementDirectives', tag);
-    if (def) {
-      return makeTerminalNodeLinkFn(el, tag, '', options, def);
-    }
-  }
-
-  /**
-   * Check if an element is a component. If yes, return
-   * a component link function.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Function|undefined}
-   */
-
-  function checkComponent(el, options) {
-    var component = checkComponentAttr(el, options);
-    if (component) {
-      var ref = findRef(el);
-      var descriptor = {
-        name: 'component',
-        ref: ref,
-        expression: component.id,
-        def: internalDirectives.component,
-        modifiers: {
-          literal: !component.dynamic
-        }
-      };
-      var componentLinkFn = function componentLinkFn(vm, el, host, scope, frag) {
-        if (ref) {
-          defineReactive((scope || vm).$refs, ref, null);
-        }
-        vm._bindDir(descriptor, el, host, scope, frag);
-      };
-      componentLinkFn.terminal = true;
-      return componentLinkFn;
-    }
-  }
-
-  /**
-   * Check an element for terminal directives in fixed order.
-   * If it finds one, return a terminal link function.
-   *
-   * @param {Element} el
-   * @param {Array} attrs
-   * @param {Object} options
-   * @return {Function} terminalLinkFn
-   */
-
-  function checkTerminalDirectives(el, attrs, options) {
-    // skip v-pre
-    if (getAttr(el, 'v-pre') !== null) {
-      return skip;
-    }
-    // skip v-else block, but only if following v-if
-    if (el.hasAttribute('v-else')) {
-      var prev = el.previousElementSibling;
-      if (prev && prev.hasAttribute('v-if')) {
-        return skip;
-      }
-    }
-
-    var attr, name, value, modifiers, matched, dirName, rawName, arg, def, termDef;
-    for (var i = 0, j = attrs.length; i < j; i++) {
-      attr = attrs[i];
-      name = attr.name.replace(modifierRE, '');
-      if (matched = name.match(dirAttrRE)) {
-        def = resolveAsset(options, 'directives', matched[1]);
-        if (def && def.terminal) {
-          if (!termDef || (def.priority || DEFAULT_TERMINAL_PRIORITY) > termDef.priority) {
-            termDef = def;
-            rawName = attr.name;
-            modifiers = parseModifiers(attr.name);
-            value = attr.value;
-            dirName = matched[1];
-            arg = matched[2];
-          }
-        }
-      }
-    }
-
-    if (termDef) {
-      return makeTerminalNodeLinkFn(el, dirName, value, options, termDef, rawName, arg, modifiers);
-    }
-  }
-
-  function skip() {}
-  skip.terminal = true;
-
-  /**
-   * Build a node link function for a terminal directive.
-   * A terminal link function terminates the current
-   * compilation recursion and handles compilation of the
-   * subtree in the directive.
-   *
-   * @param {Element} el
-   * @param {String} dirName
-   * @param {String} value
-   * @param {Object} options
-   * @param {Object} def
-   * @param {String} [rawName]
-   * @param {String} [arg]
-   * @param {Object} [modifiers]
-   * @return {Function} terminalLinkFn
-   */
-
-  function makeTerminalNodeLinkFn(el, dirName, value, options, def, rawName, arg, modifiers) {
-    var parsed = parseDirective(value);
-    var descriptor = {
-      name: dirName,
-      arg: arg,
-      expression: parsed.expression,
-      filters: parsed.filters,
-      raw: value,
-      attr: rawName,
-      modifiers: modifiers,
-      def: def
-    };
-    // check ref for v-for and router-view
-    if (dirName === 'for' || dirName === 'router-view') {
-      descriptor.ref = findRef(el);
-    }
-    var fn = function terminalNodeLinkFn(vm, el, host, scope, frag) {
-      if (descriptor.ref) {
-        defineReactive((scope || vm).$refs, descriptor.ref, null);
-      }
-      vm._bindDir(descriptor, el, host, scope, frag);
-    };
-    fn.terminal = true;
-    return fn;
-  }
-
-  /**
-   * Compile the directives on an element and return a linker.
-   *
-   * @param {Array|NamedNodeMap} attrs
-   * @param {Object} options
-   * @return {Function}
-   */
-
-  function compileDirectives(attrs, options) {
-    var i = attrs.length;
-    var dirs = [];
-    var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens, matched;
-    while (i--) {
-      attr = attrs[i];
-      name = rawName = attr.name;
-      value = rawValue = attr.value;
-      tokens = parseText(value);
-      // reset arg
-      arg = null;
-      // check modifiers
-      modifiers = parseModifiers(name);
-      name = name.replace(modifierRE, '');
-
-      // attribute interpolations
-      if (tokens) {
-        value = tokensToExp(tokens);
-        arg = name;
-        pushDir('bind', directives.bind, tokens);
-        // warn against mixing mustaches with v-bind
-        if ('development' !== 'production') {
-          if (name === 'class' && Array.prototype.some.call(attrs, function (attr) {
-            return attr.name === ':class' || attr.name === 'v-bind:class';
-          })) {
-            warn('class="' + rawValue + '": Do not mix mustache interpolation ' + 'and v-bind for "class" on the same element. Use one or the other.', options);
-          }
-        }
-      } else
-
-        // special attribute: transition
-        if (transitionRE.test(name)) {
-          modifiers.literal = !bindRE.test(name);
-          pushDir('transition', internalDirectives.transition);
-        } else
-
-          // event handlers
-          if (onRE.test(name)) {
-            arg = name.replace(onRE, '');
-            pushDir('on', directives.on);
-          } else
-
-            // attribute bindings
-            if (bindRE.test(name)) {
-              dirName = name.replace(bindRE, '');
-              if (dirName === 'style' || dirName === 'class') {
-                pushDir(dirName, internalDirectives[dirName]);
-              } else {
-                arg = dirName;
-                pushDir('bind', directives.bind);
-              }
-            } else
-
-              // normal directives
-              if (matched = name.match(dirAttrRE)) {
-                dirName = matched[1];
-                arg = matched[2];
-
-                // skip v-else (when used with v-show)
-                if (dirName === 'else') {
-                  continue;
-                }
-
-                dirDef = resolveAsset(options, 'directives', dirName, true);
-                if (dirDef) {
-                  pushDir(dirName, dirDef);
-                }
-              }
-    }
-
-    /**
-     * Push a directive.
-     *
-     * @param {String} dirName
-     * @param {Object|Function} def
-     * @param {Array} [interpTokens]
-     */
-
-    function pushDir(dirName, def, interpTokens) {
-      var hasOneTimeToken = interpTokens && hasOneTime(interpTokens);
-      var parsed = !hasOneTimeToken && parseDirective(value);
-      dirs.push({
-        name: dirName,
-        attr: rawName,
-        raw: rawValue,
-        def: def,
-        arg: arg,
-        modifiers: modifiers,
-        // conversion from interpolation strings with one-time token
-        // to expression is differed until directive bind time so that we
-        // have access to the actual vm context for one-time bindings.
-        expression: parsed && parsed.expression,
-        filters: parsed && parsed.filters,
-        interp: interpTokens,
-        hasOneTime: hasOneTimeToken
-      });
-    }
-
-    if (dirs.length) {
-      return makeNodeLinkFn(dirs);
-    }
-  }
-
-  /**
-   * Parse modifiers from directive attribute name.
-   *
-   * @param {String} name
-   * @return {Object}
-   */
-
-  function parseModifiers(name) {
-    var res = Object.create(null);
-    var match = name.match(modifierRE);
-    if (match) {
-      var i = match.length;
-      while (i--) {
-        res[match[i].slice(1)] = true;
-      }
-    }
-    return res;
-  }
-
-  /**
-   * Build a link function for all directives on a single node.
-   *
-   * @param {Array} directives
-   * @return {Function} directivesLinkFn
-   */
-
-  function makeNodeLinkFn(directives) {
-    return function nodeLinkFn(vm, el, host, scope, frag) {
-      // reverse apply because it's sorted low to high
-      var i = directives.length;
-      while (i--) {
-        vm._bindDir(directives[i], el, host, scope, frag);
-      }
-    };
-  }
-
-  /**
-   * Check if an interpolation string contains one-time tokens.
-   *
-   * @param {Array} tokens
-   * @return {Boolean}
-   */
-
-  function hasOneTime(tokens) {
-    var i = tokens.length;
-    while (i--) {
-      if (tokens[i].oneTime) return true;
-    }
-  }
-
-  function isScript(el) {
-    return el.tagName === 'SCRIPT' && (!el.hasAttribute('type') || el.getAttribute('type') === 'text/javascript');
-  }
-
-  var specialCharRE = /[^\w\-:\.]/;
-
-  /**
-   * Process an element or a DocumentFragment based on a
-   * instance option object. This allows us to transclude
-   * a template node/fragment before the instance is created,
-   * so the processed fragment can then be cloned and reused
-   * in v-for.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Element|DocumentFragment}
-   */
-
-  function transclude(el, options) {
-    // extract container attributes to pass them down
-    // to compiler, because they need to be compiled in
-    // parent scope. we are mutating the options object here
-    // assuming the same object will be used for compile
-    // right after this.
-    if (options) {
-      options._containerAttrs = extractAttrs(el);
-    }
-    // for template tags, what we want is its content as
-    // a documentFragment (for fragment instances)
-    if (isTemplate(el)) {
-      el = parseTemplate(el);
-    }
-    if (options) {
-      if (options._asComponent && !options.template) {
-        options.template = '<slot></slot>';
-      }
-      if (options.template) {
-        options._content = extractContent(el);
-        el = transcludeTemplate(el, options);
-      }
-    }
-    if (isFragment(el)) {
-      // anchors for fragment instance
-      // passing in `persist: true` to avoid them being
-      // discarded by IE during template cloning
-      prepend(createAnchor('v-start', true), el);
-      el.appendChild(createAnchor('v-end', true));
-    }
-    return el;
-  }
-
-  /**
-   * Process the template option.
-   * If the replace option is true this will swap the $el.
-   *
-   * @param {Element} el
-   * @param {Object} options
-   * @return {Element|DocumentFragment}
-   */
-
-  function transcludeTemplate(el, options) {
-    var template = options.template;
-    var frag = parseTemplate(template, true);
-    if (frag) {
-      var replacer = frag.firstChild;
-      var tag = replacer.tagName && replacer.tagName.toLowerCase();
-      if (options.replace) {
-        /* istanbul ignore if */
-        if (el === document.body) {
-          'development' !== 'production' && warn('You are mounting an instance with a template to ' + '<body>. This will replace <body> entirely. You ' + 'should probably use `replace: false` here.');
-        }
-        // there are many cases where the instance must
-        // become a fragment instance: basically anything that
-        // can create more than 1 root nodes.
-        if (
-        // multi-children template
-        frag.childNodes.length > 1 ||
-        // non-element template
-        replacer.nodeType !== 1 ||
-        // single nested component
-        tag === 'component' || resolveAsset(options, 'components', tag) || hasBindAttr(replacer, 'is') ||
-        // element directive
-        resolveAsset(options, 'elementDirectives', tag) ||
-        // for block
-        replacer.hasAttribute('v-for') ||
-        // if block
-        replacer.hasAttribute('v-if')) {
-          return frag;
-        } else {
-          options._replacerAttrs = extractAttrs(replacer);
-          mergeAttrs(el, replacer);
-          return replacer;
-        }
-      } else {
-        el.appendChild(frag);
-        return el;
-      }
-    } else {
-      'development' !== 'production' && warn('Invalid template option: ' + template);
-    }
-  }
-
-  /**
-   * Helper to extract a component container's attributes
-   * into a plain object array.
-   *
-   * @param {Element} el
-   * @return {Array}
-   */
-
-  function extractAttrs(el) {
-    if (el.nodeType === 1 && el.hasAttributes()) {
-      return toArray(el.attributes);
-    }
-  }
-
-  /**
-   * Merge the attributes of two elements, and make sure
-   * the class names are merged properly.
-   *
-   * @param {Element} from
-   * @param {Element} to
-   */
-
-  function mergeAttrs(from, to) {
-    var attrs = from.attributes;
-    var i = attrs.length;
-    var name, value;
-    while (i--) {
-      name = attrs[i].name;
-      value = attrs[i].value;
-      if (!to.hasAttribute(name) && !specialCharRE.test(name)) {
-        to.setAttribute(name, value);
-      } else if (name === 'class' && !parseText(value) && (value = value.trim())) {
-        value.split(/\s+/).forEach(function (cls) {
-          addClass(to, cls);
-        });
-      }
-    }
-  }
-
-  /**
-   * Scan and determine slot content distribution.
-   * We do this during transclusion instead at compile time so that
-   * the distribution is decoupled from the compilation order of
-   * the slots.
-   *
-   * @param {Element|DocumentFragment} template
-   * @param {Element} content
-   * @param {Vue} vm
-   */
-
-  function resolveSlots(vm, content) {
-    if (!content) {
-      return;
-    }
-    var contents = vm._slotContents = Object.create(null);
-    var el, name;
-    for (var i = 0, l = content.children.length; i < l; i++) {
-      el = content.children[i];
-      /* eslint-disable no-cond-assign */
-      if (name = el.getAttribute('slot')) {
-        (contents[name] || (contents[name] = [])).push(el);
-      }
-      /* eslint-enable no-cond-assign */
-      if ('development' !== 'production' && getBindAttr(el, 'slot')) {
-        warn('The "slot" attribute must be static.', vm.$parent);
-      }
-    }
-    for (name in contents) {
-      contents[name] = extractFragment(contents[name], content);
-    }
-    if (content.hasChildNodes()) {
-      var nodes = content.childNodes;
-      if (nodes.length === 1 && nodes[0].nodeType === 3 && !nodes[0].data.trim()) {
-        return;
-      }
-      contents['default'] = extractFragment(content.childNodes, content);
-    }
-  }
-
-  /**
-   * Extract qualified content nodes from a node list.
-   *
-   * @param {NodeList} nodes
-   * @return {DocumentFragment}
-   */
-
-  function extractFragment(nodes, parent) {
-    var frag = document.createDocumentFragment();
-    nodes = toArray(nodes);
-    for (var i = 0, l = nodes.length; i < l; i++) {
-      var node = nodes[i];
-      if (isTemplate(node) && !node.hasAttribute('v-if') && !node.hasAttribute('v-for')) {
-        parent.removeChild(node);
-        node = parseTemplate(node, true);
-      }
-      frag.appendChild(node);
-    }
-    return frag;
-  }
-
-
-
-  var compiler = Object.freeze({
-    compile: compile,
-    compileAndLinkProps: compileAndLinkProps,
-    compileRoot: compileRoot,
-    transclude: transclude,
-    resolveSlots: resolveSlots
-  });
-
-  function stateMixin (Vue) {
-    /**
-     * Accessor for `$data` property, since setting $data
-     * requires observing the new object and updating
-     * proxied properties.
-     */
-
-    Object.defineProperty(Vue.prototype, '$data', {
-      get: function get() {
-        return this._data;
-      },
-      set: function set(newData) {
-        if (newData !== this._data) {
-          this._setData(newData);
-        }
-      }
-    });
-
-    /**
-     * Setup the scope of an instance, which contains:
-     * - observed data
-     * - computed properties
-     * - user methods
-     * - meta properties
-     */
-
-    Vue.prototype._initState = function () {
-      this._initProps();
-      this._initMeta();
-      this._initMethods();
-      this._initData();
-      this._initComputed();
-    };
-
-    /**
-     * Initialize props.
-     */
-
-    Vue.prototype._initProps = function () {
-      var options = this.$options;
-      var el = options.el;
-      var props = options.props;
-      if (props && !el) {
-        'development' !== 'production' && warn('Props will not be compiled if no `el` option is ' + 'provided at instantiation.', this);
-      }
-      // make sure to convert string selectors into element now
-      el = options.el = query(el);
-      this._propsUnlinkFn = el && el.nodeType === 1 && props
-      // props must be linked in proper scope if inside v-for
-      ? compileAndLinkProps(this, el, props, this._scope) : null;
-    };
-
-    /**
-     * Initialize the data.
-     */
-
-    Vue.prototype._initData = function () {
-      var dataFn = this.$options.data;
-      var data = this._data = dataFn ? dataFn() : {};
-      if (!isPlainObject(data)) {
-        data = {};
-        'development' !== 'production' && warn('data functions should return an object.', this);
-      }
-      var props = this._props;
-      // proxy data on instance
-      var keys = Object.keys(data);
-      var i, key;
-      i = keys.length;
-      while (i--) {
-        key = keys[i];
-        // there are two scenarios where we can proxy a data key:
-        // 1. it's not already defined as a prop
-        // 2. it's provided via a instantiation option AND there are no
-        //    template prop present
-        if (!props || !hasOwn(props, key)) {
-          this._proxy(key);
-        } else if ('development' !== 'production') {
-          warn('Data field "' + key + '" is already defined ' + 'as a prop. To provide default value for a prop, use the "default" ' + 'prop option; if you want to pass prop values to an instantiation ' + 'call, use the "propsData" option.', this);
-        }
-      }
-      // observe data
-      observe(data, this);
-    };
-
-    /**
-     * Swap the instance's $data. Called in $data's setter.
-     *
-     * @param {Object} newData
-     */
-
-    Vue.prototype._setData = function (newData) {
-      newData = newData || {};
-      var oldData = this._data;
-      this._data = newData;
-      var keys, key, i;
-      // unproxy keys not present in new data
-      keys = Object.keys(oldData);
-      i = keys.length;
-      while (i--) {
-        key = keys[i];
-        if (!(key in newData)) {
-          this._unproxy(key);
-        }
-      }
-      // proxy keys not already proxied,
-      // and trigger change for changed values
-      keys = Object.keys(newData);
-      i = keys.length;
-      while (i--) {
-        key = keys[i];
-        if (!hasOwn(this, key)) {
-          // new property
-          this._proxy(key);
-        }
-      }
-      oldData.__ob__.removeVm(this);
-      observe(newData, this);
-      this._digest();
-    };
-
-    /**
-     * Proxy a property, so that
-     * vm.prop === vm._data.prop
-     *
-     * @param {String} key
-     */
-
-    Vue.prototype._proxy = function (key) {
-      if (!isReserved(key)) {
-        // need to store ref to self here
-        // because these getter/setters might
-        // be called by child scopes via
-        // prototype inheritance.
-        var self = this;
-        Object.defineProperty(self, key, {
-          configurable: true,
-          enumerable: true,
-          get: function proxyGetter() {
-            return self._data[key];
-          },
-          set: function proxySetter(val) {
-            self._data[key] = val;
-          }
-        });
-      }
-    };
-
-    /**
-     * Unproxy a property.
-     *
-     * @param {String} key
-     */
-
-    Vue.prototype._unproxy = function (key) {
-      if (!isReserved(key)) {
-        delete this[key];
-      }
-    };
-
-    /**
-     * Force update on every watcher in scope.
-     */
-
-    Vue.prototype._digest = function () {
-      for (var i = 0, l = this._watchers.length; i < l; i++) {
-        this._watchers[i].update(true); // shallow updates
-      }
-    };
-
-    /**
-     * Setup computed properties. They are essentially
-     * special getter/setters
-     */
-
-    function noop() {}
-    Vue.prototype._initComputed = function () {
-      var computed = this.$options.computed;
-      if (computed) {
-        for (var key in computed) {
-          var userDef = computed[key];
-          var def = {
-            enumerable: true,
-            configurable: true
-          };
-          if (typeof userDef === 'function') {
-            def.get = makeComputedGetter(userDef, this);
-            def.set = noop;
-          } else {
-            def.get = userDef.get ? userDef.cache !== false ? makeComputedGetter(userDef.get, this) : bind(userDef.get, this) : noop;
-            def.set = userDef.set ? bind(userDef.set, this) : noop;
-          }
-          Object.defineProperty(this, key, def);
-        }
-      }
-    };
-
-    function makeComputedGetter(getter, owner) {
-      var watcher = new Watcher(owner, getter, null, {
-        lazy: true
-      });
-      return function computedGetter() {
-        if (watcher.dirty) {
-          watcher.evaluate();
-        }
-        if (Dep.target) {
-          watcher.depend();
-        }
-        return watcher.value;
-      };
-    }
-
-    /**
-     * Setup instance methods. Methods must be bound to the
-     * instance since they might be passed down as a prop to
-     * child components.
-     */
-
-    Vue.prototype._initMethods = function () {
-      var methods = this.$options.methods;
-      if (methods) {
-        for (var key in methods) {
-          this[key] = bind(methods[key], this);
-        }
-      }
-    };
-
-    /**
-     * Initialize meta information like $index, $key & $value.
-     */
-
-    Vue.prototype._initMeta = function () {
-      var metas = this.$options._meta;
-      if (metas) {
-        for (var key in metas) {
-          defineReactive(this, key, metas[key]);
-        }
-      }
-    };
-  }
-
-  var eventRE = /^v-on:|^@/;
-
-  function eventsMixin (Vue) {
-    /**
-     * Setup the instance's option events & watchers.
-     * If the value is a string, we pull it from the
-     * instance's methods by name.
-     */
-
-    Vue.prototype._initEvents = function () {
-      var options = this.$options;
-      if (options._asComponent) {
-        registerComponentEvents(this, options.el);
-      }
-      registerCallbacks(this, '$on', options.events);
-      registerCallbacks(this, '$watch', options.watch);
-    };
-
-    /**
-     * Register v-on events on a child component
-     *
-     * @param {Vue} vm
-     * @param {Element} el
-     */
-
-    function registerComponentEvents(vm, el) {
-      var attrs = el.attributes;
-      var name, value, handler;
-      for (var i = 0, l = attrs.length; i < l; i++) {
-        name = attrs[i].name;
-        if (eventRE.test(name)) {
-          name = name.replace(eventRE, '');
-          // force the expression into a statement so that
-          // it always dynamically resolves the method to call (#2670)
-          // kinda ugly hack, but does the job.
-          value = attrs[i].value;
-          if (isSimplePath(value)) {
-            value += '.apply(this, $arguments)';
-          }
-          handler = (vm._scope || vm._context).$eval(value, true);
-          handler._fromParent = true;
-          vm.$on(name.replace(eventRE), handler);
-        }
-      }
-    }
-
-    /**
-     * Register callbacks for option events and watchers.
-     *
-     * @param {Vue} vm
-     * @param {String} action
-     * @param {Object} hash
-     */
-
-    function registerCallbacks(vm, action, hash) {
-      if (!hash) return;
-      var handlers, key, i, j;
-      for (key in hash) {
-        handlers = hash[key];
-        if (isArray(handlers)) {
-          for (i = 0, j = handlers.length; i < j; i++) {
-            register(vm, action, key, handlers[i]);
-          }
-        } else {
-          register(vm, action, key, handlers);
-        }
-      }
-    }
-
-    /**
-     * Helper to register an event/watch callback.
-     *
-     * @param {Vue} vm
-     * @param {String} action
-     * @param {String} key
-     * @param {Function|String|Object} handler
-     * @param {Object} [options]
-     */
-
-    function register(vm, action, key, handler, options) {
-      var type = typeof handler;
-      if (type === 'function') {
-        vm[action](key, handler, options);
-      } else if (type === 'string') {
-        var methods = vm.$options.methods;
-        var method = methods && methods[handler];
-        if (method) {
-          vm[action](key, method, options);
-        } else {
-          'development' !== 'production' && warn('Unknown method: "' + handler + '" when ' + 'registering callback for ' + action + ': "' + key + '".', vm);
-        }
-      } else if (handler && type === 'object') {
-        register(vm, action, key, handler.handler, handler);
-      }
-    }
-
-    /**
-     * Setup recursive attached/detached calls
-     */
-
-    Vue.prototype._initDOMHooks = function () {
-      this.$on('hook:attached', onAttached);
-      this.$on('hook:detached', onDetached);
-    };
-
-    /**
-     * Callback to recursively call attached hook on children
-     */
-
-    function onAttached() {
-      if (!this._isAttached) {
-        this._isAttached = true;
-        this.$children.forEach(callAttach);
-      }
-    }
-
-    /**
-     * Iterator to call attached hook
-     *
-     * @param {Vue} child
-     */
-
-    function callAttach(child) {
-      if (!child._isAttached && inDoc(child.$el)) {
-        child._callHook('attached');
-      }
-    }
-
-    /**
-     * Callback to recursively call detached hook on children
-     */
-
-    function onDetached() {
-      if (this._isAttached) {
-        this._isAttached = false;
-        this.$children.forEach(callDetach);
-      }
-    }
-
-    /**
-     * Iterator to call detached hook
-     *
-     * @param {Vue} child
-     */
-
-    function callDetach(child) {
-      if (child._isAttached && !inDoc(child.$el)) {
-        child._callHook('detached');
-      }
-    }
-
-    /**
-     * Trigger all handlers for a hook
-     *
-     * @param {String} hook
-     */
-
-    Vue.prototype._callHook = function (hook) {
-      this.$emit('pre-hook:' + hook);
-      var handlers = this.$options[hook];
-      if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
-          handlers[i].call(this);
-        }
-      }
-      this.$emit('hook:' + hook);
-    };
-  }
-
-  function noop$1() {}
-
-  /**
-   * A directive links a DOM element with a piece of data,
-   * which is the result of evaluating an expression.
-   * It registers a watcher with the expression and calls
-   * the DOM update function when a change is triggered.
-   *
-   * @param {Object} descriptor
-   *                 - {String} name
-   *                 - {Object} def
-   *                 - {String} expression
-   *                 - {Array<Object>} [filters]
-   *                 - {Object} [modifiers]
-   *                 - {Boolean} literal
-   *                 - {String} attr
-   *                 - {String} arg
-   *                 - {String} raw
-   *                 - {String} [ref]
-   *                 - {Array<Object>} [interp]
-   *                 - {Boolean} [hasOneTime]
-   * @param {Vue} vm
-   * @param {Node} el
-   * @param {Vue} [host] - transclusion host component
-   * @param {Object} [scope] - v-for scope
-   * @param {Fragment} [frag] - owner fragment
-   * @constructor
-   */
-  function Directive(descriptor, vm, el, host, scope, frag) {
-    this.vm = vm;
-    this.el = el;
-    // copy descriptor properties
-    this.descriptor = descriptor;
-    this.name = descriptor.name;
-    this.expression = descriptor.expression;
-    this.arg = descriptor.arg;
-    this.modifiers = descriptor.modifiers;
-    this.filters = descriptor.filters;
-    this.literal = this.modifiers && this.modifiers.literal;
-    // private
-    this._locked = false;
-    this._bound = false;
-    this._listeners = null;
-    // link context
-    this._host = host;
-    this._scope = scope;
-    this._frag = frag;
-    // store directives on node in dev mode
-    if ('development' !== 'production' && this.el) {
-      this.el._vue_directives = this.el._vue_directives || [];
-      this.el._vue_directives.push(this);
-    }
-  }
-
-  /**
-   * Initialize the directive, mixin definition properties,
-   * setup the watcher, call definition bind() and update()
-   * if present.
-   */
-
-  Directive.prototype._bind = function () {
-    var name = this.name;
-    var descriptor = this.descriptor;
-
-    // remove attribute
-    if ((name !== 'cloak' || this.vm._isCompiled) && this.el && this.el.removeAttribute) {
-      var attr = descriptor.attr || 'v-' + name;
-      this.el.removeAttribute(attr);
-    }
-
-    // copy def properties
-    var def = descriptor.def;
-    if (typeof def === 'function') {
-      this.update = def;
-    } else {
-      extend(this, def);
-    }
-
-    // setup directive params
-    this._setupParams();
-
-    // initial bind
-    if (this.bind) {
-      this.bind();
-    }
-    this._bound = true;
-
-    if (this.literal) {
-      this.update && this.update(descriptor.raw);
-    } else if ((this.expression || this.modifiers) && (this.update || this.twoWay) && !this._checkStatement()) {
-      // wrapped updater for context
-      var dir = this;
-      if (this.update) {
-        this._update = function (val, oldVal) {
-          if (!dir._locked) {
-            dir.update(val, oldVal);
-          }
-        };
-      } else {
-        this._update = noop$1;
-      }
-      var preProcess = this._preProcess ? bind(this._preProcess, this) : null;
-      var postProcess = this._postProcess ? bind(this._postProcess, this) : null;
-      var watcher = this._watcher = new Watcher(this.vm, this.expression, this._update, // callback
-      {
-        filters: this.filters,
-        twoWay: this.twoWay,
-        deep: this.deep,
-        preProcess: preProcess,
-        postProcess: postProcess,
-        scope: this._scope
-      });
-      // v-model with inital inline value need to sync back to
-      // model instead of update to DOM on init. They would
-      // set the afterBind hook to indicate that.
-      if (this.afterBind) {
-        this.afterBind();
-      } else if (this.update) {
-        this.update(watcher.value);
-      }
-    }
-  };
-
-  /**
-   * Setup all param attributes, e.g. track-by,
-   * transition-mode, etc...
-   */
-
-  Directive.prototype._setupParams = function () {
-    if (!this.params) {
-      return;
-    }
-    var params = this.params;
-    // swap the params array with a fresh object.
-    this.params = Object.create(null);
-    var i = params.length;
-    var key, val, mappedKey;
-    while (i--) {
-      key = hyphenate(params[i]);
-      mappedKey = camelize(key);
-      val = getBindAttr(this.el, key);
-      if (val != null) {
-        // dynamic
-        this._setupParamWatcher(mappedKey, val);
-      } else {
-        // static
-        val = getAttr(this.el, key);
-        if (val != null) {
-          this.params[mappedKey] = val === '' ? true : val;
-        }
-      }
-    }
-  };
-
-  /**
-   * Setup a watcher for a dynamic param.
-   *
-   * @param {String} key
-   * @param {String} expression
-   */
-
-  Directive.prototype._setupParamWatcher = function (key, expression) {
-    var self = this;
-    var called = false;
-    var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) {
-      self.params[key] = val;
-      // since we are in immediate mode,
-      // only call the param change callbacks if this is not the first update.
-      if (called) {
-        var cb = self.paramWatchers && self.paramWatchers[key];
-        if (cb) {
-          cb.call(self, val, oldVal);
-        }
-      } else {
-        called = true;
-      }
-    }, {
-      immediate: true,
-      user: false
-    });(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch);
-  };
-
-  /**
-   * Check if the directive is a function caller
-   * and if the expression is a callable one. If both true,
-   * we wrap up the expression and use it as the event
-   * handler.
-   *
-   * e.g. on-click="a++"
-   *
-   * @return {Boolean}
-   */
-
-  Directive.prototype._checkStatement = function () {
-    var expression = this.expression;
-    if (expression && this.acceptStatement && !isSimplePath(expression)) {
-      var fn = parseExpression(expression).get;
-      var scope = this._scope || this.vm;
-      var handler = function handler(e) {
-        scope.$event = e;
-        fn.call(scope, scope);
-        scope.$event = null;
-      };
-      if (this.filters) {
-        handler = scope._applyFilters(handler, null, this.filters);
-      }
-      this.update(handler);
-      return true;
-    }
-  };
-
-  /**
-   * Set the corresponding value with the setter.
-   * This should only be used in two-way directives
-   * e.g. v-model.
-   *
-   * @param {*} value
-   * @public
-   */
-
-  Directive.prototype.set = function (value) {
-    /* istanbul ignore else */
-    if (this.twoWay) {
-      this._withLock(function () {
-        this._watcher.set(value);
-      });
-    } else if ('development' !== 'production') {
-      warn('Directive.set() can only be used inside twoWay' + 'directives.');
-    }
-  };
-
-  /**
-   * Execute a function while preventing that function from
-   * triggering updates on this directive instance.
-   *
-   * @param {Function} fn
-   */
-
-  Directive.prototype._withLock = function (fn) {
-    var self = this;
-    self._locked = true;
-    fn.call(self);
-    nextTick(function () {
-      self._locked = false;
-    });
-  };
-
-  /**
-   * Convenience method that attaches a DOM event listener
-   * to the directive element and autometically tears it down
-   * during unbind.
-   *
-   * @param {String} event
-   * @param {Function} handler
-   * @param {Boolean} [useCapture]
-   */
-
-  Directive.prototype.on = function (event, handler, useCapture) {
-    on(this.el, event, handler, useCapture);(this._listeners || (this._listeners = [])).push([event, handler]);
-  };
-
-  /**
-   * Teardown the watcher and call unbind.
-   */
-
-  Directive.prototype._teardown = function () {
-    if (this._bound) {
-      this._bound = false;
-      if (this.unbind) {
-        this.unbind();
-      }
-      if (this._watcher) {
-        this._watcher.teardown();
-      }
-      var listeners = this._listeners;
-      var i;
-      if (listeners) {
-        i = listeners.length;
-        while (i--) {
-          off(this.el, listeners[i][0], listeners[i][1]);
-        }
-      }
-      var unwatchFns = this._paramUnwatchFns;
-      if (unwatchFns) {
-        i = unwatchFns.length;
-        while (i--) {
-          unwatchFns[i]();
-        }
-      }
-      if ('development' !== 'production' && this.el) {
-        this.el._vue_directives.$remove(this);
-      }
-      this.vm = this.el = this._watcher = this._listeners = null;
-    }
-  };
-
-  function lifecycleMixin (Vue) {
-    /**
-     * Update v-ref for component.
-     *
-     * @param {Boolean} remove
-     */
-
-    Vue.prototype._updateRef = function (remove) {
-      var ref = this.$options._ref;
-      if (ref) {
-        var refs = (this._scope || this._context).$refs;
-        if (remove) {
-          if (refs[ref] === this) {
-            refs[ref] = null;
-          }
-        } else {
-          refs[ref] = this;
-        }
-      }
-    };
-
-    /**
-     * Transclude, compile and link element.
-     *
-     * If a pre-compiled linker is available, that means the
-     * passed in element will be pre-transcluded and compiled
-     * as well - all we need to do is to call the linker.
-     *
-     * Otherwise we need to call transclude/compile/link here.
-     *
-     * @param {Element} el
-     */
-
-    Vue.prototype._compile = function (el) {
-      var options = this.$options;
-
-      // transclude and init element
-      // transclude can potentially replace original
-      // so we need to keep reference; this step also injects
-      // the template and caches the original attributes
-      // on the container node and replacer node.
-      var original = el;
-      el = transclude(el, options);
-      this._initElement(el);
-
-      // handle v-pre on root node (#2026)
-      if (el.nodeType === 1 && getAttr(el, 'v-pre') !== null) {
-        return;
-      }
-
-      // root is always compiled per-instance, because
-      // container attrs and props can be different every time.
-      var contextOptions = this._context && this._context.$options;
-      var rootLinker = compileRoot(el, options, contextOptions);
-
-      // resolve slot distribution
-      resolveSlots(this, options._content);
-
-      // compile and link the rest
-      var contentLinkFn;
-      var ctor = this.constructor;
-      // component compilation can be cached
-      // as long as it's not using inline-template
-      if (options._linkerCachable) {
-        contentLinkFn = ctor.linker;
-        if (!contentLinkFn) {
-          contentLinkFn = ctor.linker = compile(el, options);
-        }
-      }
-
-      // link phase
-      // make sure to link root with prop scope!
-      var rootUnlinkFn = rootLinker(this, el, this._scope);
-      var contentUnlinkFn = contentLinkFn ? contentLinkFn(this, el) : compile(el, options)(this, el);
-
-      // register composite unlink function
-      // to be called during instance destruction
-      this._unlinkFn = function () {
-        rootUnlinkFn();
-        // passing destroying: true to avoid searching and
-        // splicing the directives
-        contentUnlinkFn(true);
-      };
-
-      // finally replace original
-      if (options.replace) {
-        replace(original, el);
-      }
-
-      this._isCompiled = true;
-      this._callHook('compiled');
-    };
-
-    /**
-     * Initialize instance element. Called in the public
-     * $mount() method.
-     *
-     * @param {Element} el
-     */
-
-    Vue.prototype._initElement = function (el) {
-      if (isFragment(el)) {
-        this._isFragment = true;
-        this.$el = this._fragmentStart = el.firstChild;
-        this._fragmentEnd = el.lastChild;
-        // set persisted text anchors to empty
-        if (this._fragmentStart.nodeType === 3) {
-          this._fragmentStart.data = this._fragmentEnd.data = '';
-        }
-        this._fragment = el;
-      } else {
-        this.$el = el;
-      }
-      this.$el.__vue__ = this;
-      this._callHook('beforeCompile');
-    };
-
-    /**
-     * Create and bind a directive to an element.
-     *
-     * @param {Object} descriptor - parsed directive descriptor
-     * @param {Node} node   - target node
-     * @param {Vue} [host] - transclusion host component
-     * @param {Object} [scope] - v-for scope
-     * @param {Fragment} [frag] - owner fragment
-     */
-
-    Vue.prototype._bindDir = function (descriptor, node, host, scope, frag) {
-      this._directives.push(new Directive(descriptor, this, node, host, scope, frag));
-    };
-
-    /**
-     * Teardown an instance, unobserves the data, unbind all the
-     * directives, turn off all the event listeners, etc.
-     *
-     * @param {Boolean} remove - whether to remove the DOM node.
-     * @param {Boolean} deferCleanup - if true, defer cleanup to
-     *                                 be called later
-     */
-
-    Vue.prototype._destroy = function (remove, deferCleanup) {
-      if (this._isBeingDestroyed) {
-        if (!deferCleanup) {
-          this._cleanup();
-        }
-        return;
-      }
-
-      var destroyReady;
-      var pendingRemoval;
-
-      var self = this;
-      // Cleanup should be called either synchronously or asynchronoysly as
-      // callback of this.$remove(), or if remove and deferCleanup are false.
-      // In any case it should be called after all other removing, unbinding and
-      // turning of is done
-      var cleanupIfPossible = function cleanupIfPossible() {
-        if (destroyReady && !pendingRemoval && !deferCleanup) {
-          self._cleanup();
-        }
-      };
-
-      // remove DOM element
-      if (remove && this.$el) {
-        pendingRemoval = true;
-        this.$remove(function () {
-          pendingRemoval = false;
-          cleanupIfPossible();
-        });
-      }
-
-      this._callHook('beforeDestroy');
-      this._isBeingDestroyed = true;
-      var i;
-      // remove self from parent. only necessary
-      // if parent is not being destroyed as well.
-      var parent = this.$parent;
-      if (parent && !parent._isBeingDestroyed) {
-        parent.$children.$remove(this);
-        // unregister ref (remove: true)
-        this._updateRef(true);
-      }
-      // destroy all children.
-      i = this.$children.length;
-      while (i--) {
-        this.$children[i].$destroy();
-      }
-      // teardown props
-      if (this._propsUnlinkFn) {
-        this._propsUnlinkFn();
-      }
-      // teardown all directives. this also tearsdown all
-      // directive-owned watchers.
-      if (this._unlinkFn) {
-        this._unlinkFn();
-      }
-      i = this._watchers.length;
-      while (i--) {
-        this._watchers[i].teardown();
-      }
-      // remove reference to self on $el
-      if (this.$el) {
-        this.$el.__vue__ = null;
-      }
-
-      destroyReady = true;
-      cleanupIfPossible();
-    };
-
-    /**
-     * Clean up to ensure garbage collection.
-     * This is called after the leave transition if there
-     * is any.
-     */
-
-    Vue.prototype._cleanup = function () {
-      if (this._isDestroyed) {
-        return;
-      }
-      // remove self from owner fragment
-      // do it in cleanup so that we can call $destroy with
-      // defer right when a fragment is about to be removed.
-      if (this._frag) {
-        this._frag.children.$remove(this);
-      }
-      // remove reference from data ob
-      // frozen object may not have observer.
-      if (this._data && this._data.__ob__) {
-        this._data.__ob__.removeVm(this);
-      }
-      // Clean up references to private properties and other
-      // instances. preserve reference to _data so that proxy
-      // accessors still work. The only potential side effect
-      // here is that mutating the instance after it's destroyed
-      // may affect the state of other components that are still
-      // observing the same object, but that seems to be a
-      // reasonable responsibility for the user rather than
-      // always throwing an error on them.
-      this.$el = this.$parent = this.$root = this.$children = this._watchers = this._context = this._scope = this._directives = null;
-      // call the last hook...
-      this._isDestroyed = true;
-      this._callHook('destroyed');
-      // turn off all instance listeners.
-      this.$off();
-    };
-  }
-
-  function miscMixin (Vue) {
-    /**
-     * Apply a list of filter (descriptors) to a value.
-     * Using plain for loops here because this will be called in
-     * the getter of any watcher with filters so it is very
-     * performance sensitive.
-     *
-     * @param {*} value
-     * @param {*} [oldValue]
-     * @param {Array} filters
-     * @param {Boolean} write
-     * @return {*}
-     */
-
-    Vue.prototype._applyFilters = function (value, oldValue, filters, write) {
-      var filter, fn, args, arg, offset, i, l, j, k;
-      for (i = 0, l = filters.length; i < l; i++) {
-        filter = filters[write ? l - i - 1 : i];
-        fn = resolveAsset(this.$options, 'filters', filter.name, true);
-        if (!fn) continue;
-        fn = write ? fn.write : fn.read || fn;
-        if (typeof fn !== 'function') continue;
-        args = write ? [value, oldValue] : [value];
-        offset = write ? 2 : 1;
-        if (filter.args) {
-          for (j = 0, k = filter.args.length; j < k; j++) {
-            arg = filter.args[j];
-            args[j + offset] = arg.dynamic ? this.$get(arg.value) : arg.value;
-          }
-        }
-        value = fn.apply(this, args);
-      }
-      return value;
-    };
-
-    /**
-     * Resolve a component, depending on whether the component
-     * is defined normally or using an async factory function.
-     * Resolves synchronously if already resolved, otherwise
-     * resolves asynchronously and caches the resolved
-     * constructor on the factory.
-     *
-     * @param {String|Function} value
-     * @param {Function} cb
-     */
-
-    Vue.prototype._resolveComponent = function (value, cb) {
-      var factory;
-      if (typeof value === 'function') {
-        factory = value;
-      } else {
-        factory = resolveAsset(this.$options, 'components', value, true);
-      }
-      /* istanbul ignore if */
-      if (!factory) {
-        return;
-      }
-      // async component factory
-      if (!factory.options) {
-        if (factory.resolved) {
-          // cached
-          cb(factory.resolved);
-        } else if (factory.requested) {
-          // pool callbacks
-          factory.pendingCallbacks.push(cb);
-        } else {
-          factory.requested = true;
-          var cbs = factory.pendingCallbacks = [cb];
-          factory.call(this, function resolve(res) {
-            if (isPlainObject(res)) {
-              res = Vue.extend(res);
-            }
-            // cache resolved
-            factory.resolved = res;
-            // invoke callbacks
-            for (var i = 0, l = cbs.length; i < l; i++) {
-              cbs[i](res);
-            }
-          }, function reject(reason) {
-            'development' !== 'production' && warn('Failed to resolve async component' + (typeof value === 'string' ? ': ' + value : '') + '. ' + (reason ? '\nReason: ' + reason : ''));
-          });
-        }
-      } else {
-        // normal component
-        cb(factory);
-      }
-    };
-  }
-
-  var filterRE$1 = /[^|]\|[^|]/;
-
-  function dataAPI (Vue) {
-    /**
-     * Get the value from an expression on this vm.
-     *
-     * @param {String} exp
-     * @param {Boolean} [asStatement]
-     * @return {*}
-     */
-
-    Vue.prototype.$get = function (exp, asStatement) {
-      var res = parseExpression(exp);
-      if (res) {
-        if (asStatement) {
-          var self = this;
-          return function statementHandler() {
-            self.$arguments = toArray(arguments);
-            var result = res.get.call(self, self);
-            self.$arguments = null;
-            return result;
-          };
-        } else {
-          try {
-            return res.get.call(this, this);
-          } catch (e) {}
-        }
-      }
-    };
-
-    /**
-     * Set the value from an expression on this vm.
-     * The expression must be a valid left-hand
-     * expression in an assignment.
-     *
-     * @param {String} exp
-     * @param {*} val
-     */
-
-    Vue.prototype.$set = function (exp, val) {
-      var res = parseExpression(exp, true);
-      if (res && res.set) {
-        res.set.call(this, this, val);
-      }
-    };
-
-    /**
-     * Delete a property on the VM
-     *
-     * @param {String} key
-     */
-
-    Vue.prototype.$delete = function (key) {
-      del(this._data, key);
-    };
-
-    /**
-     * Watch an expression, trigger callback when its
-     * value changes.
-     *
-     * @param {String|Function} expOrFn
-     * @param {Function} cb
-     * @param {Object} [options]
-     *                 - {Boolean} deep
-     *                 - {Boolean} immediate
-     * @return {Function} - unwatchFn
-     */
-
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-      var vm = this;
-      var parsed;
-      if (typeof expOrFn === 'string') {
-        parsed = parseDirective(expOrFn);
-        expOrFn = parsed.expression;
-      }
-      var watcher = new Watcher(vm, expOrFn, cb, {
-        deep: options && options.deep,
-        sync: options && options.sync,
-        filters: parsed && parsed.filters,
-        user: !options || options.user !== false
-      });
-      if (options && options.immediate) {
-        cb.call(vm, watcher.value);
-      }
-      return function unwatchFn() {
-        watcher.teardown();
-      };
-    };
-
-    /**
-     * Evaluate a text directive, including filters.
-     *
-     * @param {String} text
-     * @param {Boolean} [asStatement]
-     * @return {String}
-     */
-
-    Vue.prototype.$eval = function (text, asStatement) {
-      // check for filters.
-      if (filterRE$1.test(text)) {
-        var dir = parseDirective(text);
-        // the filter regex check might give false positive
-        // for pipes inside strings, so it's possible that
-        // we don't get any filters here
-        var val = this.$get(dir.expression, asStatement);
-        return dir.filters ? this._applyFilters(val, null, dir.filters) : val;
-      } else {
-        // no filter
-        return this.$get(text, asStatement);
-      }
-    };
-
-    /**
-     * Interpolate a piece of template text.
-     *
-     * @param {String} text
-     * @return {String}
-     */
-
-    Vue.prototype.$interpolate = function (text) {
-      var tokens = parseText(text);
-      var vm = this;
-      if (tokens) {
-        if (tokens.length === 1) {
-          return vm.$eval(tokens[0].value) + '';
-        } else {
-          return tokens.map(function (token) {
-            return token.tag ? vm.$eval(token.value) : token.value;
-          }).join('');
-        }
-      } else {
-        return text;
-      }
-    };
-
-    /**
-     * Log instance data as a plain JS object
-     * so that it is easier to inspect in console.
-     * This method assumes console is available.
-     *
-     * @param {String} [path]
-     */
-
-    Vue.prototype.$log = function (path) {
-      var data = path ? getPath(this._data, path) : this._data;
-      if (data) {
-        data = clean(data);
-      }
-      // include computed fields
-      if (!path) {
-        var key;
-        for (key in this.$options.computed) {
-          data[key] = clean(this[key]);
-        }
-        if (this._props) {
-          for (key in this._props) {
-            data[key] = clean(this[key]);
-          }
-        }
-      }
-      console.log(data);
-    };
-
-    /**
-     * "clean" a getter/setter converted object into a plain
-     * object copy.
-     *
-     * @param {Object} - obj
-     * @return {Object}
-     */
-
-    function clean(obj) {
-      return JSON.parse(JSON.stringify(obj));
-    }
-  }
-
-  function domAPI (Vue) {
-    /**
-     * Convenience on-instance nextTick. The callback is
-     * auto-bound to the instance, and this avoids component
-     * modules having to rely on the global Vue.
-     *
-     * @param {Function} fn
-     */
-
-    Vue.prototype.$nextTick = function (fn) {
-      nextTick(fn, this);
-    };
-
-    /**
-     * Append instance to target
-     *
-     * @param {Node} target
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition] - defaults to true
-     */
-
-    Vue.prototype.$appendTo = function (target, cb, withTransition) {
-      return insert(this, target, cb, withTransition, append, appendWithTransition);
-    };
-
-    /**
-     * Prepend instance to target
-     *
-     * @param {Node} target
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition] - defaults to true
-     */
-
-    Vue.prototype.$prependTo = function (target, cb, withTransition) {
-      target = query(target);
-      if (target.hasChildNodes()) {
-        this.$before(target.firstChild, cb, withTransition);
-      } else {
-        this.$appendTo(target, cb, withTransition);
-      }
-      return this;
-    };
-
-    /**
-     * Insert instance before target
-     *
-     * @param {Node} target
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition] - defaults to true
-     */
-
-    Vue.prototype.$before = function (target, cb, withTransition) {
-      return insert(this, target, cb, withTransition, beforeWithCb, beforeWithTransition);
-    };
-
-    /**
-     * Insert instance after target
-     *
-     * @param {Node} target
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition] - defaults to true
-     */
-
-    Vue.prototype.$after = function (target, cb, withTransition) {
-      target = query(target);
-      if (target.nextSibling) {
-        this.$before(target.nextSibling, cb, withTransition);
-      } else {
-        this.$appendTo(target.parentNode, cb, withTransition);
-      }
-      return this;
-    };
-
-    /**
-     * Remove instance from DOM
-     *
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition] - defaults to true
-     */
-
-    Vue.prototype.$remove = function (cb, withTransition) {
-      if (!this.$el.parentNode) {
-        return cb && cb();
-      }
-      var inDocument = this._isAttached && inDoc(this.$el);
-      // if we are not in document, no need to check
-      // for transitions
-      if (!inDocument) withTransition = false;
-      var self = this;
-      var realCb = function realCb() {
-        if (inDocument) self._callHook('detached');
-        if (cb) cb();
-      };
-      if (this._isFragment) {
-        removeNodeRange(this._fragmentStart, this._fragmentEnd, this, this._fragment, realCb);
-      } else {
-        var op = withTransition === false ? removeWithCb : removeWithTransition;
-        op(this.$el, this, realCb);
-      }
-      return this;
-    };
-
-    /**
-     * Shared DOM insertion function.
-     *
-     * @param {Vue} vm
-     * @param {Element} target
-     * @param {Function} [cb]
-     * @param {Boolean} [withTransition]
-     * @param {Function} op1 - op for non-transition insert
-     * @param {Function} op2 - op for transition insert
-     * @return vm
-     */
-
-    function insert(vm, target, cb, withTransition, op1, op2) {
-      target = query(target);
-      var targetIsDetached = !inDoc(target);
-      var op = withTransition === false || targetIsDetached ? op1 : op2;
-      var shouldCallHook = !targetIsDetached && !vm._isAttached && !inDoc(vm.$el);
-      if (vm._isFragment) {
-        mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) {
-          op(node, target, vm);
-        });
-        cb && cb();
-      } else {
-        op(vm.$el, target, vm, cb);
-      }
-      if (shouldCallHook) {
-        vm._callHook('attached');
-      }
-      return vm;
-    }
-
-    /**
-     * Check for selectors
-     *
-     * @param {String|Element} el
-     */
-
-    function query(el) {
-      return typeof el === 'string' ? document.querySelector(el) : el;
-    }
-
-    /**
-     * Append operation that takes a callback.
-     *
-     * @param {Node} el
-     * @param {Node} target
-     * @param {Vue} vm - unused
-     * @param {Function} [cb]
-     */
-
-    function append(el, target, vm, cb) {
-      target.appendChild(el);
-      if (cb) cb();
-    }
-
-    /**
-     * InsertBefore operation that takes a callback.
-     *
-     * @param {Node} el
-     * @param {Node} target
-     * @param {Vue} vm - unused
-     * @param {Function} [cb]
-     */
-
-    function beforeWithCb(el, target, vm, cb) {
-      before(el, target);
-      if (cb) cb();
-    }
-
-    /**
-     * Remove operation that takes a callback.
-     *
-     * @param {Node} el
-     * @param {Vue} vm - unused
-     * @param {Function} [cb]
-     */
-
-    function removeWithCb(el, vm, cb) {
-      remove(el);
-      if (cb) cb();
-    }
-  }
-
-  function eventsAPI (Vue) {
-    /**
-     * Listen on the given `event` with `fn`.
-     *
-     * @param {String} event
-     * @param {Function} fn
-     */
-
-    Vue.prototype.$on = function (event, fn) {
-      (this._events[event] || (this._events[event] = [])).push(fn);
-      modifyListenerCount(this, event, 1);
-      return this;
-    };
-
-    /**
-     * Adds an `event` listener that will be invoked a single
-     * time then automatically removed.
-     *
-     * @param {String} event
-     * @param {Function} fn
-     */
-
-    Vue.prototype.$once = function (event, fn) {
-      var self = this;
-      function on() {
-        self.$off(event, on);
-        fn.apply(this, arguments);
-      }
-      on.fn = fn;
-      this.$on(event, on);
-      return this;
-    };
-
-    /**
-     * Remove the given callback for `event` or all
-     * registered callbacks.
-     *
-     * @param {String} event
-     * @param {Function} fn
-     */
-
-    Vue.prototype.$off = function (event, fn) {
-      var cbs;
-      // all
-      if (!arguments.length) {
-        if (this.$parent) {
-          for (event in this._events) {
-            cbs = this._events[event];
-            if (cbs) {
-              modifyListenerCount(this, event, -cbs.length);
-            }
-          }
-        }
-        this._events = {};
-        return this;
-      }
-      // specific event
-      cbs = this._events[event];
-      if (!cbs) {
-        return this;
-      }
-      if (arguments.length === 1) {
-        modifyListenerCount(this, event, -cbs.length);
-        this._events[event] = null;
-        return this;
-      }
-      // specific handler
-      var cb;
-      var i = cbs.length;
-      while (i--) {
-        cb = cbs[i];
-        if (cb === fn || cb.fn === fn) {
-          modifyListenerCount(this, event, -1);
-          cbs.splice(i, 1);
-          break;
-        }
-      }
-      return this;
-    };
-
-    /**
-     * Trigger an event on self.
-     *
-     * @param {String|Object} event
-     * @return {Boolean} shouldPropagate
-     */
-
-    Vue.prototype.$emit = function (event) {
-      var isSource = typeof event === 'string';
-      event = isSource ? event : event.name;
-      var cbs = this._events[event];
-      var shouldPropagate = isSource || !cbs;
-      if (cbs) {
-        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-        // this is a somewhat hacky solution to the question raised
-        // in #2102: for an inline component listener like <comp @test="doThis">,
-        // the propagation handling is somewhat broken. Therefore we
-        // need to treat these inline callbacks differently.
-        var hasParentCbs = isSource && cbs.some(function (cb) {
-          return cb._fromParent;
-        });
-        if (hasParentCbs) {
-          shouldPropagate = false;
-        }
-        var args = toArray(arguments, 1);
-        for (var i = 0, l = cbs.length; i < l; i++) {
-          var cb = cbs[i];
-          var res = cb.apply(this, args);
-          if (res === true && (!hasParentCbs || cb._fromParent)) {
-            shouldPropagate = true;
-          }
-        }
-      }
-      return shouldPropagate;
-    };
-
-    /**
-     * Recursively broadcast an event to all children instances.
-     *
-     * @param {String|Object} event
-     * @param {...*} additional arguments
-     */
-
-    Vue.prototype.$broadcast = function (event) {
-      var isSource = typeof event === 'string';
-      event = isSource ? event : event.name;
-      // if no child has registered for this event,
-      // then there's no need to broadcast.
-      if (!this._eventsCount[event]) return;
-      var children = this.$children;
-      var args = toArray(arguments);
-      if (isSource) {
-        // use object event to indicate non-source emit
-        // on children
-        args[0] = { name: event, source: this };
-      }
-      for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var shouldPropagate = child.$emit.apply(child, args);
-        if (shouldPropagate) {
-          child.$broadcast.apply(child, args);
-        }
-      }
-      return this;
-    };
-
-    /**
-     * Recursively propagate an event up the parent chain.
-     *
-     * @param {String} event
-     * @param {...*} additional arguments
-     */
-
-    Vue.prototype.$dispatch = function (event) {
-      var shouldPropagate = this.$emit.apply(this, arguments);
-      if (!shouldPropagate) return;
-      var parent = this.$parent;
-      var args = toArray(arguments);
-      // use object event to indicate non-source emit
-      // on parents
-      args[0] = { name: event, source: this };
-      while (parent) {
-        shouldPropagate = parent.$emit.apply(parent, args);
-        parent = shouldPropagate ? parent.$parent : null;
-      }
-      return this;
-    };
-
-    /**
-     * Modify the listener counts on all parents.
-     * This bookkeeping allows $broadcast to return early when
-     * no child has listened to a certain event.
-     *
-     * @param {Vue} vm
-     * @param {String} event
-     * @param {Number} count
-     */
-
-    var hookRE = /^hook:/;
-    function modifyListenerCount(vm, event, count) {
-      var parent = vm.$parent;
-      // hooks do not get broadcasted so no need
-      // to do bookkeeping for them
-      if (!parent || !count || hookRE.test(event)) return;
-      while (parent) {
-        parent._eventsCount[event] = (parent._eventsCount[event] || 0) + count;
-        parent = parent.$parent;
-      }
-    }
-  }
-
-  function lifecycleAPI (Vue) {
-    /**
-     * Set instance target element and kick off the compilation
-     * process. The passed in `el` can be a selector string, an
-     * existing Element, or a DocumentFragment (for block
-     * instances).
-     *
-     * @param {Element|DocumentFragment|string} el
-     * @public
-     */
-
-    Vue.prototype.$mount = function (el) {
-      if (this._isCompiled) {
-        'development' !== 'production' && warn('$mount() should be called only once.', this);
-        return;
-      }
-      el = query(el);
-      if (!el) {
-        el = document.createElement('div');
-      }
-      this._compile(el);
-      this._initDOMHooks();
-      if (inDoc(this.$el)) {
-        this._callHook('attached');
-        ready.call(this);
-      } else {
-        this.$once('hook:attached', ready);
-      }
-      return this;
-    };
-
-    /**
-     * Mark an instance as ready.
-     */
-
-    function ready() {
-      this._isAttached = true;
-      this._isReady = true;
-      this._callHook('ready');
-    }
-
-    /**
-     * Teardown the instance, simply delegate to the internal
-     * _destroy.
-     *
-     * @param {Boolean} remove
-     * @param {Boolean} deferCleanup
-     */
-
-    Vue.prototype.$destroy = function (remove, deferCleanup) {
-      this._destroy(remove, deferCleanup);
-    };
-
-    /**
-     * Partially compile a piece of DOM and return a
-     * decompile function.
-     *
-     * @param {Element|DocumentFragment} el
-     * @param {Vue} [host]
-     * @param {Object} [scope]
-     * @param {Fragment} [frag]
-     * @return {Function}
-     */
-
-    Vue.prototype.$compile = function (el, host, scope, frag) {
-      return compile(el, this.$options, true)(this, el, host, scope, frag);
-    };
-  }
-
-  /**
-   * The exposed Vue constructor.
-   *
-   * API conventions:
-   * - public API methods/properties are prefixed with `$`
-   * - internal methods/properties are prefixed with `_`
-   * - non-prefixed properties are assumed to be proxied user
-   *   data.
-   *
-   * @constructor
-   * @param {Object} [options]
-   * @public
-   */
-
-  function Vue(options) {
-    this._init(options);
-  }
-
-  // install internals
-  initMixin(Vue);
-  stateMixin(Vue);
-  eventsMixin(Vue);
-  lifecycleMixin(Vue);
-  miscMixin(Vue);
-
-  // install instance APIs
-  dataAPI(Vue);
-  domAPI(Vue);
-  eventsAPI(Vue);
-  lifecycleAPI(Vue);
-
-  var slot = {
-
-    priority: SLOT,
-    params: ['name'],
-
-    bind: function bind() {
-      // this was resolved during component transclusion
-      var name = this.params.name || 'default';
-      var content = this.vm._slotContents && this.vm._slotContents[name];
-      if (!content || !content.hasChildNodes()) {
-        this.fallback();
-      } else {
-        this.compile(content.cloneNode(true), this.vm._context, this.vm);
-      }
-    },
-
-    compile: function compile(content, context, host) {
-      if (content && context) {
-        if (this.el.hasChildNodes() && content.childNodes.length === 1 && content.childNodes[0].nodeType === 1 && content.childNodes[0].hasAttribute('v-if')) {
-          // if the inserted slot has v-if
-          // inject fallback content as the v-else
-          var elseBlock = document.createElement('template');
-          elseBlock.setAttribute('v-else', '');
-          elseBlock.innerHTML = this.el.innerHTML;
-          // the else block should be compiled in child scope
-          elseBlock._context = this.vm;
-          content.appendChild(elseBlock);
-        }
-        var scope = host ? host._scope : this._scope;
-        this.unlink = context.$compile(content, host, scope, this._frag);
-      }
-      if (content) {
-        replace(this.el, content);
-      } else {
-        remove(this.el);
-      }
-    },
-
-    fallback: function fallback() {
-      this.compile(extractContent(this.el, true), this.vm);
-    },
-
-    unbind: function unbind() {
-      if (this.unlink) {
-        this.unlink();
-      }
-    }
-  };
-
-  var partial = {
-
-    priority: PARTIAL,
-
-    params: ['name'],
-
-    // watch changes to name for dynamic partials
-    paramWatchers: {
-      name: function name(value) {
-        vIf.remove.call(this);
-        if (value) {
-          this.insert(value);
-        }
-      }
-    },
-
-    bind: function bind() {
-      this.anchor = createAnchor('v-partial');
-      replace(this.el, this.anchor);
-      this.insert(this.params.name);
-    },
-
-    insert: function insert(id) {
-      var partial = resolveAsset(this.vm.$options, 'partials', id, true);
-      if (partial) {
-        this.factory = new FragmentFactory(this.vm, partial);
-        vIf.insert.call(this);
-      }
-    },
-
-    unbind: function unbind() {
-      if (this.frag) {
-        this.frag.destroy();
-      }
-    }
-  };
-
-  var elementDirectives = {
-    slot: slot,
-    partial: partial
-  };
-
-  var convertArray = vFor._postProcess;
-
-  /**
-   * Limit filter for arrays
-   *
-   * @param {Number} n
-   * @param {Number} offset (Decimal expected)
-   */
-
-  function limitBy(arr, n, offset) {
-    offset = offset ? parseInt(offset, 10) : 0;
-    n = toNumber(n);
-    return typeof n === 'number' ? arr.slice(offset, offset + n) : arr;
-  }
-
-  /**
-   * Filter filter for arrays
-   *
-   * @param {String} search
-   * @param {String} [delimiter]
-   * @param {String} ...dataKeys
-   */
-
-  function filterBy(arr, search, delimiter) {
-    arr = convertArray(arr);
-    if (search == null) {
-      return arr;
-    }
-    if (typeof search === 'function') {
-      return arr.filter(search);
-    }
-    // cast to lowercase string
-    search = ('' + search).toLowerCase();
-    // allow optional `in` delimiter
-    // because why not
-    var n = delimiter === 'in' ? 3 : 2;
-    // extract and flatten keys
-    var keys = Array.prototype.concat.apply([], toArray(arguments, n));
-    var res = [];
-    var item, key, val, j;
-    for (var i = 0, l = arr.length; i < l; i++) {
-      item = arr[i];
-      val = item && item.$value || item;
-      j = keys.length;
-      if (j) {
-        while (j--) {
-          key = keys[j];
-          if (key === '$key' && contains(item.$key, search) || contains(getPath(val, key), search)) {
-            res.push(item);
-            break;
-          }
-        }
-      } else if (contains(item, search)) {
-        res.push(item);
-      }
-    }
-    return res;
-  }
-
-  /**
-   * Filter filter for arrays
-   *
-   * @param {String|Array<String>|Function} ...sortKeys
-   * @param {Number} [order]
-   */
-
-  function orderBy(arr) {
-    var comparator = null;
-    var sortKeys = undefined;
-    arr = convertArray(arr);
-
-    // determine order (last argument)
-    var args = toArray(arguments, 1);
-    var order = args[args.length - 1];
-    if (typeof order === 'number') {
-      order = order < 0 ? -1 : 1;
-      args = args.length > 1 ? args.slice(0, -1) : args;
-    } else {
-      order = 1;
-    }
-
-    // determine sortKeys & comparator
-    var firstArg = args[0];
-    if (!firstArg) {
-      return arr;
-    } else if (typeof firstArg === 'function') {
-      // custom comparator
-      comparator = function (a, b) {
-        return firstArg(a, b) * order;
-      };
-    } else {
-      // string keys. flatten first
-      sortKeys = Array.prototype.concat.apply([], args);
-      comparator = function (a, b, i) {
-        i = i || 0;
-        return i >= sortKeys.length - 1 ? baseCompare(a, b, i) : baseCompare(a, b, i) || comparator(a, b, i + 1);
-      };
-    }
-
-    function baseCompare(a, b, sortKeyIndex) {
-      var sortKey = sortKeys[sortKeyIndex];
-      if (sortKey) {
-        if (sortKey !== '$key') {
-          if (isObject(a) && '$value' in a) a = a.$value;
-          if (isObject(b) && '$value' in b) b = b.$value;
-        }
-        a = isObject(a) ? getPath(a, sortKey) : a;
-        b = isObject(b) ? getPath(b, sortKey) : b;
-      }
-      return a === b ? 0 : a > b ? order : -order;
-    }
-
-    // sort on a copy to avoid mutating original array
-    return arr.slice().sort(comparator);
-  }
-
-  /**
-   * String contain helper
-   *
-   * @param {*} val
-   * @param {String} search
-   */
-
-  function contains(val, search) {
-    var i;
-    if (isPlainObject(val)) {
-      var keys = Object.keys(val);
-      i = keys.length;
-      while (i--) {
-        if (contains(val[keys[i]], search)) {
-          return true;
-        }
-      }
-    } else if (isArray(val)) {
-      i = val.length;
-      while (i--) {
-        if (contains(val[i], search)) {
-          return true;
-        }
-      }
-    } else if (val != null) {
-      return val.toString().toLowerCase().indexOf(search) > -1;
-    }
-  }
-
-  var digitsRE = /(\d{3})(?=\d)/g;
-
-  // asset collections must be a plain object.
-  var filters = {
-
-    orderBy: orderBy,
-    filterBy: filterBy,
-    limitBy: limitBy,
-
-    /**
-     * Stringify value.
-     *
-     * @param {Number} indent
-     */
-
-    json: {
-      read: function read(value, indent) {
-        return typeof value === 'string' ? value : JSON.stringify(value, null, arguments.length > 1 ? indent : 2);
-      },
-      write: function write(value) {
-        try {
-          return JSON.parse(value);
-        } catch (e) {
-          return value;
-        }
-      }
-    },
-
-    /**
-     * 'abc' => 'Abc'
-     */
-
-    capitalize: function capitalize(value) {
-      if (!value && value !== 0) return '';
-      value = value.toString();
-      return value.charAt(0).toUpperCase() + value.slice(1);
-    },
-
-    /**
-     * 'abc' => 'ABC'
-     */
-
-    uppercase: function uppercase(value) {
-      return value || value === 0 ? value.toString().toUpperCase() : '';
-    },
-
-    /**
-     * 'AbC' => 'abc'
-     */
-
-    lowercase: function lowercase(value) {
-      return value || value === 0 ? value.toString().toLowerCase() : '';
-    },
-
-    /**
-     * 12345 => $12,345.00
-     *
-     * @param {String} sign
-     * @param {Number} decimals Decimal places
-     */
-
-    currency: function currency(value, _currency, decimals) {
-      value = parseFloat(value);
-      if (!isFinite(value) || !value && value !== 0) return '';
-      _currency = _currency != null ? _currency : '$';
-      decimals = decimals != null ? decimals : 2;
-      var stringified = Math.abs(value).toFixed(decimals);
-      var _int = decimals ? stringified.slice(0, -1 - decimals) : stringified;
-      var i = _int.length % 3;
-      var head = i > 0 ? _int.slice(0, i) + (_int.length > 3 ? ',' : '') : '';
-      var _float = decimals ? stringified.slice(-1 - decimals) : '';
-      var sign = value < 0 ? '-' : '';
-      return sign + _currency + head + _int.slice(i).replace(digitsRE, '$1,') + _float;
-    },
-
-    /**
-     * 'item' => 'items'
-     *
-     * @params
-     *  an array of strings corresponding to
-     *  the single, double, triple ... forms of the word to
-     *  be pluralized. When the number to be pluralized
-     *  exceeds the length of the args, it will use the last
-     *  entry in the array.
-     *
-     *  e.g. ['single', 'double', 'triple', 'multiple']
-     */
-
-    pluralize: function pluralize(value) {
-      var args = toArray(arguments, 1);
-      var length = args.length;
-      if (length > 1) {
-        var index = value % 10 - 1;
-        return index in args ? args[index] : args[length - 1];
-      } else {
-        return args[0] + (value === 1 ? '' : 's');
-      }
-    },
-
-    /**
-     * Debounce a handler function.
-     *
-     * @param {Function} handler
-     * @param {Number} delay = 300
-     * @return {Function}
-     */
-
-    debounce: function debounce(handler, delay) {
-      if (!handler) return;
-      if (!delay) {
-        delay = 300;
-      }
-      return _debounce(handler, delay);
-    }
-  };
-
-  function installGlobalAPI (Vue) {
-    /**
-     * Vue and every constructor that extends Vue has an
-     * associated options object, which can be accessed during
-     * compilation steps as `this.constructor.options`.
-     *
-     * These can be seen as the default options of every
-     * Vue instance.
-     */
-
-    Vue.options = {
-      directives: directives,
-      elementDirectives: elementDirectives,
-      filters: filters,
-      transitions: {},
-      components: {},
-      partials: {},
-      replace: true
-    };
-
-    /**
-     * Expose useful internals
-     */
-
-    Vue.util = util;
-    Vue.config = config;
-    Vue.set = set;
-    Vue['delete'] = del;
-    Vue.nextTick = nextTick;
-
-    /**
-     * The following are exposed for advanced usage / plugins
-     */
-
-    Vue.compiler = compiler;
-    Vue.FragmentFactory = FragmentFactory;
-    Vue.internalDirectives = internalDirectives;
-    Vue.parsers = {
-      path: path,
-      text: text,
-      template: template,
-      directive: directive,
-      expression: expression
-    };
-
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-
-    Vue.cid = 0;
-    var cid = 1;
-
-    /**
-     * Class inheritance
-     *
-     * @param {Object} extendOptions
-     */
-
-    Vue.extend = function (extendOptions) {
-      extendOptions = extendOptions || {};
-      var Super = this;
-      var isFirstExtend = Super.cid === 0;
-      if (isFirstExtend && extendOptions._Ctor) {
-        return extendOptions._Ctor;
-      }
-      var name = extendOptions.name || Super.options.name;
-      if ('development' !== 'production') {
-        if (!/^[a-zA-Z][\w-]*$/.test(name)) {
-          warn('Invalid component name: "' + name + '". Component names ' + 'can only contain alphanumeric characaters and the hyphen.');
-          name = null;
-        }
-      }
-      var Sub = createClass(name || 'VueComponent');
-      Sub.prototype = Object.create(Super.prototype);
-      Sub.prototype.constructor = Sub;
-      Sub.cid = cid++;
-      Sub.options = mergeOptions(Super.options, extendOptions);
-      Sub['super'] = Super;
-      // allow further extension
-      Sub.extend = Super.extend;
-      // create asset registers, so extended classes
-      // can have their private assets too.
-      config._assetTypes.forEach(function (type) {
-        Sub[type] = Super[type];
-      });
-      // enable recursive self-lookup
-      if (name) {
-        Sub.options.components[name] = Sub;
-      }
-      // cache constructor
-      if (isFirstExtend) {
-        extendOptions._Ctor = Sub;
-      }
-      return Sub;
-    };
-
-    /**
-     * A function that returns a sub-class constructor with the
-     * given name. This gives us much nicer output when
-     * logging instances in the console.
-     *
-     * @param {String} name
-     * @return {Function}
-     */
-
-    function createClass(name) {
-      /* eslint-disable no-new-func */
-      return new Function('return function ' + classify(name) + ' (options) { this._init(options) }')();
-      /* eslint-enable no-new-func */
-    }
-
-    /**
-     * Plugin system
-     *
-     * @param {Object} plugin
-     */
-
-    Vue.use = function (plugin) {
-      /* istanbul ignore if */
-      if (plugin.installed) {
-        return;
-      }
-      // additional parameters
-      var args = toArray(arguments, 1);
-      args.unshift(this);
-      if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args);
-      } else {
-        plugin.apply(null, args);
-      }
-      plugin.installed = true;
-      return this;
-    };
-
-    /**
-     * Apply a global mixin by merging it into the default
-     * options.
-     */
-
-    Vue.mixin = function (mixin) {
-      Vue.options = mergeOptions(Vue.options, mixin);
-    };
-
-    /**
-     * Create asset registration methods with the following
-     * signature:
-     *
-     * @param {String} id
-     * @param {*} definition
-     */
-
-    config._assetTypes.forEach(function (type) {
-      Vue[type] = function (id, definition) {
-        if (!definition) {
-          return this.options[type + 's'][id];
-        } else {
-          /* istanbul ignore if */
-          if ('development' !== 'production') {
-            if (type === 'component' && (commonTagRE.test(id) || reservedTagRE.test(id))) {
-              warn('Do not use built-in or reserved HTML elements as component ' + 'id: ' + id);
-            }
-          }
-          if (type === 'component' && isPlainObject(definition)) {
-            if (!definition.name) {
-              definition.name = id;
-            }
-            definition = Vue.extend(definition);
-          }
-          this.options[type + 's'][id] = definition;
-          return definition;
-        }
-      };
-    });
-
-    // expose internal transition API
-    extend(Vue.transition, transition);
-  }
-
-  installGlobalAPI(Vue);
-
-  Vue.version = '1.0.26';
-
-  // devtools global hook
-  /* istanbul ignore next */
-  setTimeout(function () {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else if ('development' !== 'production' && inBrowser && /Chrome\/\d+/.test(window.navigator.userAgent)) {
-        console.log('Download the Vue Devtools for a better development experience:\n' + 'https://github.com/vuejs/vue-devtools');
-      }
-    }
-  }, 0);
-
-  return Vue;
-
-}));
diff --git a/app/assets/javascripts/merge_conflict_resolver.js.es6 b/app/assets/javascripts/merge_conflict_resolver.js.es6
index 6329bf8232e..77bffbcb403 100644
--- a/app/assets/javascripts/merge_conflict_resolver.js.es6
+++ b/app/assets/javascripts/merge_conflict_resolver.js.es6
@@ -1,4 +1,4 @@
-//= require lib/vue
+//= require vue
 
 class MergeConflictResolver {