/*!

 */
(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;

}));