From 61eaa271c0694cc4cf7296637b55b5481dbd3f98 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 1 Jun 2015 16:56:45 -0400
Subject: [PATCH] [release] 0.12.0-rc

---
 bower.json      |     2 +-
 component.json  |     2 +-
 dist/vue.js     | 13484 ++++++++++++++++++++++++----------------------
 dist/vue.min.js |     7 +-
 package.json    |     2 +-
 5 files changed, 6906 insertions(+), 6591 deletions(-)

diff --git a/bower.json b/bower.json
index 2b782a580b2..9adb07cffd8 100644
--- a/bower.json
+++ b/bower.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "0.12.0-beta5",
+  "version": "0.12.0-rc",
   "main": "dist/vue.js",
   "description": "Simple, Fast & Composable MVVM for building interative interfaces",
   "authors": ["Evan You <yyx990803@gmail.com>"],
diff --git a/component.json b/component.json
index bb3ba4e52a2..f416457b1e5 100644
--- a/component.json
+++ b/component.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "0.12.0-beta5",
+  "version": "0.12.0-rc",
   "main": "src/vue.js",
   "author": "Evan You <yyx990803@gmail.com>",
   "description": "Simple, Fast & Composable MVVM for building interative interfaces",
diff --git a/dist/vue.js b/dist/vue.js
index 1c646ba4a74..a85048b2dd0 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -1,3 +1,9 @@
+/**
+ * Vue.js v0.12.0-rc
+ * (c) 2015 Evan You
+ * Released under the MIT License.
+ */
+
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory();
@@ -11,41 +17,41 @@
 return /******/ (function(modules) { // webpackBootstrap
 /******/ 	// The module cache
 /******/ 	var installedModules = {};
-/******/
+
 /******/ 	// The require function
 /******/ 	function __webpack_require__(moduleId) {
-/******/
+
 /******/ 		// Check if module is in cache
 /******/ 		if(installedModules[moduleId])
 /******/ 			return installedModules[moduleId].exports;
-/******/
+
 /******/ 		// Create a new module (and put it into the cache)
 /******/ 		var module = installedModules[moduleId] = {
 /******/ 			exports: {},
 /******/ 			id: moduleId,
 /******/ 			loaded: false
 /******/ 		};
-/******/
+
 /******/ 		// Execute the module function
 /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
+
 /******/ 		// Flag the module as loaded
 /******/ 		module.loaded = true;
-/******/
+
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;
 /******/ 	}
-/******/
-/******/
+
+
 /******/ 	// expose the modules object (__webpack_modules__)
 /******/ 	__webpack_require__.m = modules;
-/******/
+
 /******/ 	// expose the module cache
 /******/ 	__webpack_require__.c = installedModules;
-/******/
+
 /******/ 	// __webpack_public_path__
 /******/ 	__webpack_require__.p = "";
-/******/
+
 /******/ 	// Load entry module and return exports
 /******/ 	return __webpack_require__(0);
 /******/ })
@@ -54,9 +60,9 @@ return /******/ (function(modules) { // webpackBootstrap
 /* 0 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
+	var _ = __webpack_require__(2)
 	var extend = _.extend
-	
+
 	/**
 	 * The exposed Vue constructor.
 	 *
@@ -70,17 +76,17 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {Object} [options]
 	 * @public
 	 */
-	
+
 	function Vue (options) {
 	  this._init(options)
 	}
-	
+
 	/**
 	 * Mixin global API
 	 */
-	
-	extend(Vue, __webpack_require__(1))
-	
+
+	extend(Vue, __webpack_require__(27))
+
 	/**
 	 * Vue and every constructor that extends Vue has an
 	 * associated options object, which can be accessed during
@@ -89,3027 +95,2541 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * These can be seen as the default options of every
 	 * Vue instance.
 	 */
-	
+
 	Vue.options = {
-	  directives  : __webpack_require__(12),
-	  filters     : __webpack_require__(13),
-	  partials    : {},
+	  directives  : __webpack_require__(28),
+	  filters     : __webpack_require__(51),
 	  transitions : {},
-	  components  : {}
+	  components  : {},
+	  elementDirectives: {}
 	}
-	
+
 	/**
 	 * Build up the prototype
 	 */
-	
+
 	var p = Vue.prototype
-	
+
 	/**
 	 * $data has a setter which does a bunch of
 	 * teardown/setup work
 	 */
-	
+
 	Object.defineProperty(p, '$data', {
 	  get: function () {
 	    return this._data
 	  },
 	  set: function (newData) {
-	    this._setData(newData)
+	    if (newData !== this._data) {
+	      this._setData(newData)
+	    }
 	  }
 	})
-	
+
 	/**
 	 * Mixin internal instance methods
 	 */
-	
-	extend(p, __webpack_require__(2))
-	extend(p, __webpack_require__(3))
-	extend(p, __webpack_require__(4))
-	extend(p, __webpack_require__(5))
-	extend(p, __webpack_require__(62))
-	
+
+	extend(p, __webpack_require__(53))
+	extend(p, __webpack_require__(54))
+	extend(p, __webpack_require__(55))
+	extend(p, __webpack_require__(1))
+	extend(p, __webpack_require__(56))
+
 	/**
 	 * Mixin public API methods
 	 */
-	
-	extend(p, __webpack_require__(6))
-	extend(p, __webpack_require__(7))
-	extend(p, __webpack_require__(8))
-	extend(p, __webpack_require__(9))
-	extend(p, __webpack_require__(10))
-	
+
+	extend(p, __webpack_require__(57))
+	extend(p, __webpack_require__(58))
+	extend(p, __webpack_require__(59))
+	extend(p, __webpack_require__(60))
+	extend(p, __webpack_require__(61))
+
 	module.exports = _.Vue = Vue
 
 /***/ },
 /* 1 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var mergeOptions = __webpack_require__(14)
-	
+	var _ = __webpack_require__(2)
+	var Directive = __webpack_require__(10)
+	var compile = __webpack_require__(22)
+	var transclude = __webpack_require__(26)
+
 	/**
-	 * Expose useful internals
+	 * 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
+	 * @return {Element}
 	 */
-	
-	exports.util = _
-	exports.nextTick = _.nextTick
-	exports.config = __webpack_require__(15)
-	
-	exports.compiler = {
-	  compile: __webpack_require__(16),
-	  transclude: __webpack_require__(17)
-	}
-	
-	exports.parsers = {
-	  path: __webpack_require__(18),
-	  text: __webpack_require__(19),
-	  template: __webpack_require__(20),
-	  directive: __webpack_require__(21),
-	  expression: __webpack_require__(22)
+
+	exports._compile = function (el) {
+	  var options = this.$options
+	  if (options._linkFn) {
+	    // pre-transcluded with linker, just use it
+	    this._initElement(el)
+	    this._unlinkFn = options._linkFn(this, el)
+	  } else {
+	    // transclude and init element
+	    // transclude can potentially replace original
+	    // so we need to keep reference
+	    var original = el
+	    el = transclude(el, options)
+	    this._initElement(el)
+	    // compile and link the rest
+	    this._unlinkFn = compile(el, options)(this, el)
+	    // finally replace original
+	    if (options.replace) {
+	      _.replace(original, el)
+	    }
+	  }
+	  return el
 	}
-	
+
 	/**
-	 * Each instance constructor, including Vue, has a unique
-	 * cid. This enables us to create wrapped "child
-	 * constructors" for prototypal inheritance and cache them.
+	 * Initialize instance element. Called in the public
+	 * $mount() method.
+	 *
+	 * @param {Element} el
 	 */
-	
-	exports.cid = 0
-	var cid = 1
-	
+
+	exports._initElement = function (el) {
+	  if (el instanceof DocumentFragment) {
+	    this._isBlock = true
+	    this.$el = this._blockStart = el.firstChild
+	    this._blockEnd = el.lastChild
+	    // set persisted text anchors to empty
+	    if (this._blockStart.nodeType === 3) {
+	      this._blockStart.data = this._blockEnd.data = ''
+	    }
+	    this._blockFragment = el
+	  } else {
+	    this.$el = el
+	  }
+	  this.$el.__vue__ = this
+	  this._callHook('beforeCompile')
+	}
+
 	/**
-	 * Class inehritance
+	 * Create and bind a directive to an element.
 	 *
-	 * @param {Object} extendOptions
+	 * @param {String} name - directive name
+	 * @param {Node} node   - target node
+	 * @param {Object} desc - parsed directive descriptor
+	 * @param {Object} def  - directive definition object
+	 * @param {Vue|undefined} host - transclusion host component
 	 */
-	
-	exports.extend = function (extendOptions) {
-	  extendOptions = extendOptions || {}
-	  var Super = this
-	  var Sub = createClass(
-	    extendOptions.name ||
-	    Super.options.name ||
-	    'VueComponent'
-	  )
-	  Sub.prototype = Object.create(Super.prototype)
-	  Sub.prototype.constructor = Sub
-	  Sub.cid = cid++
-	  Sub.options = mergeOptions(
-	    Super.options,
-	    extendOptions
+
+	exports._bindDir = function (name, node, desc, def, host) {
+	  this._directives.push(
+	    new Directive(name, node, this, desc, def, host)
 	  )
-	  Sub['super'] = Super
-	  // allow further extension
-	  Sub.extend = Super.extend
-	  // create asset registers, so extended classes
-	  // can have their private assets too.
-	  createAssetRegisters(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.
+	 * Teardown an instance, unobserves the data, unbind all the
+	 * directives, turn off all the event listeners, etc.
 	 *
-	 * @param {String} name
-	 * @return {Function}
+	 * @param {Boolean} remove - whether to remove the DOM node.
+	 * @param {Boolean} deferCleanup - if true, defer cleanup to
+	 *                                 be called later
 	 */
-	
-	function createClass (name) {
-	  return new Function(
-	    'return function ' + _.classify(name) +
-	    ' (options) { this._init(options) }'
-	  )()
+
+	exports._destroy = function (remove, deferCleanup) {
+	  if (this._isBeingDestroyed) {
+	    return
+	  }
+	  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)
+	  }
+	  // same for transclusion host.
+	  var host = this._host
+	  if (host && !host._isBeingDestroyed) {
+	    host._transCpnts.$remove(this)
+	  }
+	  // destroy all children.
+	  i = this._children.length
+	  while (i--) {
+	    this._children[i].$destroy()
+	  }
+	  // teardown all directives. this also tearsdown all
+	  // directive-owned watchers.
+	  if (this._unlinkFn) {
+	    // passing destroying: true to avoid searching and
+	    // splicing the directives
+	    this._unlinkFn(true)
+	  }
+	  i = this._watchers.length
+	  while (i--) {
+	    this._watchers[i].teardown()
+	  }
+	  // remove reference to self on $el
+	  if (this.$el) {
+	    this.$el.__vue__ = null
+	  }
+	  // remove DOM element
+	  var self = this
+	  if (remove && this.$el) {
+	    this.$remove(function () {
+	      self._cleanup()
+	    })
+	  } else if (!deferCleanup) {
+	    this._cleanup()
+	  }
 	}
-	
+
 	/**
-	 * Plugin system
+	 * Clean up to ensure garbage collection.
+	 * This is called after the leave transition if there
+	 * is any.
+	 */
+
+	exports._cleanup = function () {
+	  // remove reference from data ob
+	  this._data.__ob__.removeVm(this)
+	  this._data =
+	  this._watchers =
+	  this.$el =
+	  this.$parent =
+	  this.$root =
+	  this._children =
+	  this._transCpnts =
+	  this._directives = null
+	  // call the last hook...
+	  this._isDestroyed = true
+	  this._callHook('destroyed')
+	  // turn off all instance listeners.
+	  this.$off()
+	}
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var lang   = __webpack_require__(5)
+	var extend = lang.extend
+
+	extend(exports, lang)
+	extend(exports, __webpack_require__(6))
+	extend(exports, __webpack_require__(7))
+	extend(exports, __webpack_require__(3))
+	extend(exports, __webpack_require__(8))
+	extend(exports, __webpack_require__(9))
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var commonTagRE = /^(div|p|span|img|a|br|ul|ol|li|h1|h2|h3|h4|h5|table|tbody|tr|td|pre)$/
+
+	/**
+	 * Check if an element is a component, if yes return its
+	 * component id.
 	 *
-	 * @param {Object} plugin
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {String|undefined}
 	 */
-	
-	exports.use = function (plugin) {
-	  // 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)
+
+	exports.checkComponent = function (el, options) {
+	  var tag = el.tagName.toLowerCase()
+	  if (tag === 'component') {
+	    // dynamic syntax
+	    var exp = el.getAttribute('is')
+	    el.removeAttribute('is')
+	    return exp
+	  } else if (
+	    !commonTagRE.test(tag) &&
+	    _.resolveAsset(options, 'components', tag)
+	  ) {
+	    return tag
 	  }
-	  return this
 	}
-	
+
 	/**
-	 * Define asset registration methods on a constructor.
+	 * Create an "anchor" for performing dom insertion/removals.
+	 * This is used in a number of scenarios:
+	 * - block instance
+	 * - v-html
+	 * - v-if
+	 * - component
+	 * - repeat
 	 *
-	 * @param {Function} Constructor
+	 * @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}
 	 */
-	
-	var assetTypes = [
-	  'directive',
-	  'filter',
-	  'partial',
-	  'transition'
-	]
-	
-	function createAssetRegisters (Constructor) {
-	
-	  /* Asset registration methods share the same signature:
-	   *
-	   * @param {String} id
-	   * @param {*} definition
-	   */
-	
-	  assetTypes.forEach(function (type) {
-	    Constructor[type] = function (id, definition) {
-	      if (!definition) {
-	        return this.options[type + 's'][id]
-	      } else {
-	        this.options[type + 's'][id] = definition
-	      }
-	    }
-	  })
-	
-	  /**
-	   * Component registration needs to automatically invoke
-	   * Vue.extend on object values.
-	   *
-	   * @param {String} id
-	   * @param {Object|Function} definition
-	   */
-	
-	  Constructor.component = function (id, definition) {
-	    if (!definition) {
-	      return this.options.components[id]
-	    } else {
-	      if (_.isPlainObject(definition)) {
-	        definition.name = id
-	        definition = _.Vue.extend(definition)
-	      }
-	      this.options.components[id] = definition
-	    }
-	  }
+
+	exports.createAnchor = function (content, persist) {
+	  return config.debug
+	    ? document.createComment(content)
+	    : document.createTextNode(persist ? ' ' : '')
 	}
-	
-	createAssetRegisters(exports)
 
 /***/ },
-/* 2 */
+/* 4 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var mergeOptions = __webpack_require__(14)
-	
+	module.exports = {
+
+	  /**
+	   * The prefix to look for when parsing directives.
+	   *
+	   * @type {String}
+	   */
+
+	  prefix: 'v-',
+
+	  /**
+	   * Whether to print debug messages.
+	   * Also enables stack trace for warnings.
+	   *
+	   * @type {Boolean}
+	   */
+
+	  debug: false,
+
+	  /**
+	   * Whether to suppress warnings.
+	   *
+	   * @type {Boolean}
+	   */
+
+	  silent: false,
+
+	  /**
+	   * Whether allow observer to alter data objects'
+	   * __proto__.
+	   *
+	   * @type {Boolean}
+	   */
+
+	  proto: true,
+
+	  /**
+	   * Whether to parse mustache tags in templates.
+	   *
+	   * @type {Boolean}
+	   */
+
+	  interpolate: true,
+
+	  /**
+	   * Whether to use async rendering.
+	   */
+
+	  async: true,
+
+	  /**
+	   * Whether to warn against errors caught when evaluating
+	   * expressions.
+	   */
+
+	  warnExpressionErrors: true,
+
+	  /**
+	   * 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: [
+	    'directive',
+	    'elementDirective',
+	    'filter',
+	    'transition'
+	  ]
+
+	}
+
 	/**
-	 * The main init sequence. This is called for every
-	 * instance, including ones that are created from extended
-	 * constructors.
+	 * Interpolation delimiters.
+	 * We need to mark the changed flag so that the text parser
+	 * knows it needs to recompile the regex.
 	 *
-	 * @param {Object} options - this options object should be
-	 *                           the result of merging class
-	 *                           options and the options passed
-	 *                           in to the constructor.
+	 * @type {Array<String>}
 	 */
-	
-	exports._init = function (options) {
-	
-	  options = options || {}
-	
-	  this.$el           = null
-	  this.$parent       = options._parent
-	  this.$root         = options._root || this
-	  this.$             = {} // child vm references
-	  this.$$            = {} // element references
-	  this._watcherList  = [] // all watchers as an array
-	  this._watchers     = {} // internal watchers as a hash
-	  this._userWatchers = {} // user watchers as a hash
-	  this._directives   = [] // all directives
-	
-	  // a flag to avoid this being observed
-	  this._isVue = true
-	
-	  // events bookkeeping
-	  this._events         = {}    // registered callbacks
-	  this._eventsCount    = {}    // for $broadcast optimization
-	  this._eventCancelled = false // for event cancellation
-	
-	  // block instance properties
-	  this._isBlock     = false
-	  this._blockStart  =          // @type {CommentNode}
-	  this._blockEnd    = null     // @type {CommentNode}
-	
-	  // lifecycle state
-	  this._isCompiled  =
-	  this._isDestroyed =
-	  this._isReady     =
-	  this._isAttached  =
-	  this._isBeingDestroyed = false
-	  this._unlinkFn    = null
-	
-	  // children
-	  this._children = []
-	  this._childCtors = {}
-	
-	  // transcluded components that belong to the parent.
-	  // need to keep track of them so that we can call
-	  // attached/detached hooks on them.
-	  this._transCpnts = []
-	  this._host = options._host
-	
-	  // push self into parent / transclusion host
-	  if (this.$parent) {
-	    this.$parent._children.push(this)
-	  }
-	  if (this._host) {
-	    this._host._transCpnts.push(this)
-	  }
-	
-	  // props used in v-repeat diffing
-	  this._new = true
-	  this._reused = false
-	
-	  // merge options.
-	  options = this.$options = mergeOptions(
-	    this.constructor.options,
-	    options,
-	    this
-	  )
-	
-	  // set data after merge.
-	  this._data = options.data || {}
-	
-	  // initialize data observation and scope inheritance.
-	  this._initScope()
-	
-	  // 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 delimiters = ['{{', '}}']
+	Object.defineProperty(module.exports, 'delimiters', {
+	  get: function () {
+	    return delimiters
+	  },
+	  set: function (val) {
+	    delimiters = val
+	    this._delimitersChanged = true
 	  }
-	}
+	})
 
 /***/ },
-/* 3 */
+/* 5 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var inDoc = _.inDoc
-	
 	/**
-	 * Setup the instance's option events & watchers.
-	 * If the value is a string, we pull it from the
-	 * instance's methods by name.
+	 * Check is a string starts with $ or _
+	 *
+	 * @param {String} str
+	 * @return {Boolean}
 	 */
-	
-	exports._initEvents = function () {
-	  var options = this.$options
-	  registerCallbacks(this, '$on', options.events)
-	  registerCallbacks(this, '$watch', options.watch)
+
+	exports.isReserved = function (str) {
+	  var c = (str + '').charCodeAt(0)
+	  return c === 0x24 || c === 0x5F
 	}
-	
+
 	/**
-	 * Register callbacks for option events and watchers.
+	 * Guard text output, make sure undefined outputs
+	 * empty string
 	 *
-	 * @param {Vue} vm
-	 * @param {String} action
-	 * @param {Object} hash
+	 * @param {*} value
+	 * @return {String}
 	 */
-	
-	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)
-	    }
-	  }
+
+	exports.toString = function (value) {
+	  return value == null
+	    ? ''
+	    : value.toString()
 	}
-	
+
 	/**
-	 * Helper to register an event/watch callback.
+	 * Check and convert possible numeric numbers before
+	 * setting back to data
 	 *
-	 * @param {Vue} vm
-	 * @param {String} action
-	 * @param {String} key
-	 * @param {*} handler
+	 * @param {*} value
+	 * @return {*|Number}
 	 */
-	
-	function register (vm, action, key, handler) {
-	  var type = typeof handler
-	  if (type === 'function') {
-	    vm[action](key, handler)
-	  } else if (type === 'string') {
-	    var methods = vm.$options.methods
-	    var method = methods && methods[handler]
-	    if (method) {
-	      vm[action](key, method)
-	    } else {
-	      _.warn(
-	        'Unknown method: "' + handler + '" when ' +
-	        'registering callback for ' + action +
-	        ': "' + key + '".'
-	      )
-	    }
-	  }
-	}
-	
-	/**
-	 * Setup recursive attached/detached calls
-	 */
-	
-	exports._initDOMHooks = function () {
-	  this.$on('hook:attached', onAttached)
-	  this.$on('hook:detached', onDetached)
+
+	exports.toNumber = function (value) {
+	  return (
+	    isNaN(value) ||
+	    value === null ||
+	    typeof value === 'boolean'
+	  ) ? value
+	    : Number(value)
 	}
-	
+
 	/**
-	 * Callback to recursively call attached hook on children
+	 * Strip quotes from a string
+	 *
+	 * @param {String} str
+	 * @return {String | false}
 	 */
-	
-	function onAttached () {
-	  this._isAttached = true
-	  this._children.forEach(callAttach)
-	  if (this._transCpnts.length) {
-	    this._transCpnts.forEach(callAttach)
-	  }
+
+	exports.stripQuotes = function (str) {
+	  var a = str.charCodeAt(0)
+	  var b = str.charCodeAt(str.length - 1)
+	  return a === b && (a === 0x22 || a === 0x27)
+	    ? str.slice(1, -1)
+	    : false
 	}
-	
+
 	/**
-	 * Iterator to call attached hook
-	 * 
-	 * @param {Vue} child
+	 * Replace helper
+	 *
+	 * @param {String} _ - matched delimiter
+	 * @param {String} c - matched char
+	 * @return {String}
 	 */
-	
-	function callAttach (child) {
-	  if (!child._isAttached && inDoc(child.$el)) {
-	    child._callHook('attached')
-	  }
+	function toUpper (_, c) {
+	  return c ? c.toUpperCase () : ''
 	}
-	
+
 	/**
-	 * Callback to recursively call detached hook on children
+	 * Camelize a hyphen-delmited string.
+	 *
+	 * @param {String} str
+	 * @return {String}
 	 */
-	
-	function onDetached () {
-	  this._isAttached = false
-	  this._children.forEach(callDetach)
-	  if (this._transCpnts.length) {
-	    this._transCpnts.forEach(callDetach)
-	  }
+
+	var camelRE = /-(\w)/g
+	exports.camelize = function (str) {
+	  return str.replace(camelRE, toUpper)
 	}
-	
+
 	/**
-	 * Iterator to call detached hook
-	 * 
-	 * @param {Vue} child
+	 * 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}
 	 */
-	
-	function callDetach (child) {
-	  if (child._isAttached && !inDoc(child.$el)) {
-	    child._callHook('detached')
-	  }
+
+	var classifyRE = /(?:^|[-_\/])(\w)/g
+	exports.classify = function (str) {
+	  return str.replace(classifyRE, toUpper)
 	}
-	
+
 	/**
-	 * Trigger all handlers for a hook
+	 * Simple bind, faster than native
 	 *
-	 * @param {String} hook
+	 * @param {Function} fn
+	 * @param {Object} ctx
+	 * @return {Function}
 	 */
-	
-	exports._callHook = function (hook) {
-	  var handlers = this.$options[hook]
-	  if (handlers) {
-	    for (var i = 0, j = handlers.length; i < j; i++) {
-	      handlers[i].call(this)
-	    }
+
+	exports.bind = function (fn, ctx) {
+	  return function (a) {
+	    var l = arguments.length
+	    return l
+	      ? l > 1
+	        ? fn.apply(ctx, arguments)
+	        : fn.call(ctx, a)
+	      : fn.call(ctx)
 	  }
-	  this.$emit('hook:' + hook)
 	}
 
-/***/ },
-/* 4 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var Observer = __webpack_require__(26)
-	var Dep = __webpack_require__(23)
-	
-	/**
-	 * Setup the scope of an instance, which contains:
-	 * - observed data
-	 * - computed properties
-	 * - user methods
-	 * - meta properties
-	 */
-	
-	exports._initScope = function () {
-	  this._initData()
-	  this._initComputed()
-	  this._initMethods()
-	  this._initMeta()
-	}
-	
 	/**
-	 * Initialize the data. 
+	 * Convert an Array-like object to a real Array.
+	 *
+	 * @param {Array-like} list
+	 * @param {Number} [start] - start index
+	 * @return {Array}
 	 */
-	
-	exports._initData = function () {
-	  // proxy data on instance
-	  var data = this._data
-	  var i, key
-	  // make sure all paramAttributes properties are observed
-	  var params = this.$options.paramAttributes
-	  if (params) {
-	    i = params.length
-	    while (i--) {
-	      key = _.camelize(params[i])
-	      if (!(key in data)) {
-	        data[key] = null
-	      }
-	    }
-	  }
-	  var keys = Object.keys(data)
-	  i = keys.length
+
+	exports.toArray = function (list, start) {
+	  start = start || 0
+	  var i = list.length - start
+	  var ret = new Array(i)
 	  while (i--) {
-	    key = keys[i]
-	    if (!_.isReserved(key)) {
-	      this._proxy(key)
-	    }
+	    ret[i] = list[i + start]
 	  }
-	  // observe data
-	  Observer.create(data).addVm(this)
+	  return ret
 	}
-	
+
 	/**
-	 * Swap the isntance's $data. Called in $data's setter.
+	 * Mix properties into target object.
 	 *
-	 * @param {Object} newData
+	 * @param {Object} to
+	 * @param {Object} from
 	 */
-	
-	exports._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 (!_.isReserved(key) && !(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 (!this.hasOwnProperty(key) && !_.isReserved(key)) {
-	      // new property
-	      this._proxy(key)
-	    }
+
+	exports.extend = function (to, from) {
+	  for (var key in from) {
+	    to[key] = from[key]
 	  }
-	  oldData.__ob__.removeVm(this)
-	  Observer.create(newData).addVm(this)
-	  this._digest()
+	  return to
 	}
-	
+
 	/**
-	 * Proxy a property, so that
-	 * vm.prop === vm._data.prop
+	 * Quick object check - this is primarily used to tell
+	 * Objects from primitive values when we know the value
+	 * is a JSON-compliant type.
 	 *
-	 * @param {String} key
+	 * @param {*} obj
+	 * @return {Boolean}
 	 */
-	
-	exports._proxy = function (key) {
-	  // need to store ref to self here
-	  // because these getter/setters might
-	  // be called by child instances!
-	  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
-	    }
-	  })
+
+	exports.isObject = function (obj) {
+	  return obj && typeof obj === 'object'
 	}
-	
+
 	/**
-	 * Unproxy a property.
+	 * Strict object type check. Only returns true
+	 * for plain JavaScript objects.
 	 *
-	 * @param {String} key
+	 * @param {*} obj
+	 * @return {Boolean}
 	 */
-	
-	exports._unproxy = function (key) {
-	  delete this[key]
+
+	var toString = Object.prototype.toString
+	exports.isPlainObject = function (obj) {
+	  return toString.call(obj) === '[object Object]'
 	}
-	
+
 	/**
-	 * Force update on every watcher in scope.
+	 * Array type check.
+	 *
+	 * @param {*} obj
+	 * @return {Boolean}
 	 */
-	
-	exports._digest = function () {
-	  var i = this._watcherList.length
-	  while (i--) {
-	    this._watcherList[i].update()
-	  }
-	  var children = this._children
-	  i = children.length
-	  while (i--) {
-	    var child = children[i]
-	    if (child.$options.inherit) {
-	      child._digest()
-	    }
-	  }
+
+	exports.isArray = function (obj) {
+	  return Array.isArray(obj)
 	}
-	
+
 	/**
-	 * Setup computed properties. They are essentially
-	 * special getter/setters
+	 * Define a non-enumerable property
+	 *
+	 * @param {Object} obj
+	 * @param {String} key
+	 * @param {*} val
+	 * @param {Boolean} [enumerable]
 	 */
-	
-	function noop () {}
-	exports._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 = _.bind(userDef, this)
-	        def.set = noop
-	      } else {
-	        def.get = userDef.get
-	          ? _.bind(userDef.get, this)
-	          : noop
-	        def.set = userDef.set
-	          ? _.bind(userDef.set, this)
-	          : noop
-	      }
-	      Object.defineProperty(this, key, def)
-	    }
-	  }
+
+	exports.define = function (obj, key, val, enumerable) {
+	  Object.defineProperty(obj, key, {
+	    value        : val,
+	    enumerable   : !!enumerable,
+	    writable     : true,
+	    configurable : true
+	  })
 	}
-	
+
 	/**
-	 * Setup instance methods. Methods must be bound to the
-	 * instance since they might be called by children
-	 * inheriting them.
+	 * 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
 	 */
-	
-	exports._initMethods = function () {
-	  var methods = this.$options.methods
-	  if (methods) {
-	    for (var key in methods) {
-	      this[key] = _.bind(methods[key], this)
+
+	exports.debounce = function(func, wait) {
+	  var timeout, args, context, timestamp, result
+	  var later = function() {
+	    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
 	  }
 	}
-	
+
 	/**
-	 * Initialize meta information like $index, $key & $value.
+	 * Manual indexOf because it's slightly faster than
+	 * native.
+	 *
+	 * @param {Array} arr
+	 * @param {*} obj
 	 */
-	
-	exports._initMeta = function () {
-	  var metas = this.$options._meta
-	  if (metas) {
-	    for (var key in metas) {
-	      this._defineMeta(key, metas[key])
-	    }
+
+	exports.indexOf = function (arr, obj) {
+	  for (var i = 0, l = arr.length; i < l; i++) {
+	    if (arr[i] === obj) return i
 	  }
+	  return -1
 	}
-	
+
 	/**
-	 * Define a meta property, e.g $index, $key, $value
-	 * which only exists on the vm instance but not in $data.
+	 * Make a cancellable version of an async callback.
 	 *
-	 * @param {String} key
-	 * @param {*} value
+	 * @param {Function} fn
+	 * @return {Function}
 	 */
-	
-	exports._defineMeta = function (key, value) {
-	  var dep = new Dep()
-	  Object.defineProperty(this, key, {
-	    enumerable: true,
-	    configurable: true,
-	    get: function metaGetter () {
-	      if (Observer.target) {
-	        Observer.target.addDep(dep)
-	      }
-	      return value
-	    },
-	    set: function metaSetter (val) {
-	      if (val !== value) {
-	        value = val
-	        dep.notify()
-	      }
+
+	exports.cancellable = function (fn) {
+	  var cb = function () {
+	    if (!cb.cancelled) {
+	      return fn.apply(this, arguments)
 	    }
-	  })
+	  }
+	  cb.cancel = function () {
+	    cb.cancelled = true
+	  }
+	  return cb
 	}
 
 /***/ },
-/* 5 */
+/* 6 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var Directive = __webpack_require__(24)
-	var compile = __webpack_require__(16)
-	var transclude = __webpack_require__(17)
-	
+	// can we use __proto__?
+	exports.hasProto = '__proto__' in {}
+
+	// Browser environment sniffing
+	var inBrowser = exports.inBrowser =
+	  typeof window !== 'undefined' &&
+	  Object.prototype.toString.call(window) !== '[object Object]'
+
+	exports.isIE9 =
+	  inBrowser &&
+	  navigator.userAgent.toLowerCase().indexOf('msie 9.0') > 0
+
+	exports.isAndroid =
+	  inBrowser &&
+	  navigator.userAgent.toLowerCase().indexOf('android') > 0
+
+	// Transition property/event sniffing
+	if (inBrowser && !exports.isIE9) {
+	  var isWebkitTrans =
+	    window.ontransitionend === undefined &&
+	    window.onwebkittransitionend !== undefined
+	  var isWebkitAnim =
+	    window.onanimationend === undefined &&
+	    window.onwebkitanimationend !== undefined
+	  exports.transitionProp = isWebkitTrans
+	    ? 'WebkitTransition'
+	    : 'transition'
+	  exports.transitionEndEvent = isWebkitTrans
+	    ? 'webkitTransitionEnd'
+	    : 'transitionend'
+	  exports.animationProp = isWebkitAnim
+	    ? 'WebkitAnimation'
+	    : 'animation'
+	  exports.animationEndEvent = isWebkitAnim
+	    ? 'webkitAnimationEnd'
+	    : 'animationend'
+	}
+
 	/**
-	 * 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.
+	 * 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 {Element} el
-	 * @return {Element}
+	 * @param {Function} cb
+	 * @param {Object} ctx
 	 */
-	
-	exports._compile = function (el) {
-	  var options = this.$options
-	  if (options._linkFn) {
-	    // pre-transcluded with linker, just use it
-	    this._initElement(el)
-	    this._unlinkFn = options._linkFn(this, el)
-	  } else {
-	    // transclude and init element
-	    // transclude can potentially replace original
-	    // so we need to keep reference
-	    var original = el
-	    el = transclude(el, options)
-	    this._initElement(el)
-	    // compile and link the rest
-	    this._unlinkFn = compile(el, options)(this, el)
-	    // finally replace original
-	    if (options.replace) {
-	      _.replace(original, el)
+
+	exports.nextTick = (function () {
+	  var callbacks = []
+	  var pending = false
+	  var timerFunc
+	  function handle () {
+	    pending = false
+	    var copies = callbacks.slice(0)
+	    callbacks = []
+	    for (var i = 0; i < copies.length; i++) {
+	      copies[i]()
 	    }
 	  }
-	  return el
-	}
-	
+	  /* istanbul ignore if */
+	  if (typeof MutationObserver !== 'undefined') {
+	    var counter = 1
+	    var observer = new MutationObserver(handle)
+	    var textNode = document.createTextNode(counter)
+	    observer.observe(textNode, {
+	      characterData: true
+	    })
+	    timerFunc = function () {
+	      counter = (counter + 1) % 2
+	      textNode.data = counter
+	    }
+	  } else {
+	    timerFunc = setTimeout
+	  }
+	  return function (cb, ctx) {
+	    var func = ctx
+	      ? function () { cb.call(ctx) }
+	      : cb
+	    callbacks.push(func)
+	    if (pending) return
+	    pending = true
+	    timerFunc(handle, 0)
+	  }
+	})()
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var config = __webpack_require__(4)
+
 	/**
-	 * Initialize instance element. Called in the public
-	 * $mount() method.
+	 * 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 byy doing the
+	 * contains() check on the node's parentNode instead of
+	 * the node itself.
 	 *
-	 * @param {Element} el
+	 * @param {Node} node
+	 * @return {Boolean}
 	 */
-	
-	exports._initElement = function (el) {
-	  if (el instanceof DocumentFragment) {
-	    this._isBlock = true
-	    this.$el = this._blockStart = el.firstChild
-	    this._blockEnd = el.lastChild
-	    this._blockFragment = el
-	  } else {
-	    this.$el = el
-	  }
-	  this.$el.__vue__ = this
-	  this._callHook('beforeCompile')
+
+	var doc =
+	  typeof document !== 'undefined' &&
+	  document.documentElement
+
+	exports.inDoc = function (node) {
+	  var parent = node && node.parentNode
+	  return doc === node ||
+	    doc === parent ||
+	    !!(parent && parent.nodeType === 1 && (doc.contains(parent)))
 	}
-	
+
 	/**
-	 * Create and bind a directive to an element.
+	 * Extract an attribute from a node.
 	 *
-	 * @param {String} name - directive name
-	 * @param {Node} node   - target node
-	 * @param {Object} desc - parsed directive descriptor
-	 * @param {Object} def  - directive definition object
-	 * @param {Vue|undefined} host - transclusion host component
-	 */
-	
-	exports._bindDir = function (name, node, desc, def, host) {
-	  this._directives.push(
-	    new Directive(name, node, this, desc, def, host)
-	  )
+	 * @param {Node} node
+	 * @param {String} attr
+	 */
+
+	exports.attr = function (node, attr) {
+	  attr = config.prefix + attr
+	  var val = node.getAttribute(attr)
+	  if (val !== null) {
+	    node.removeAttribute(attr)
+	  }
+	  return val
 	}
-	
+
 	/**
-	 * Teardown an instance, unobserves the data, unbind all the
-	 * directives, turn off all the event listeners, etc.
+	 * Insert el before target
 	 *
-	 * @param {Boolean} remove - whether to remove the DOM node.
-	 * @param {Boolean} deferCleanup - if true, defer cleanup to
-	 *                                 be called later
+	 * @param {Element} el
+	 * @param {Element} target
 	 */
-	
-	exports._destroy = function (remove, deferCleanup) {
-	  if (this._isBeingDestroyed) {
-	    return
-	  }
-	  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)
-	  }
-	  // same for transclusion host.
-	  var host = this._host
-	  if (host && !host._isBeingDestroyed) {
-	    host._transCpnts.$remove(this)
-	  }
-	  // destroy all children.
-	  i = this._children.length
-	  while (i--) {
-	    this._children[i].$destroy()
-	  }
-	  // teardown all directives. this also tearsdown all
-	  // directive-owned watchers.
-	  if (this._unlinkFn) {
-	    // passing destroying: true to avoid searching and
-	    // splicing the directives
-	    this._unlinkFn(true)
-	  }
-	  // teardown all user watchers.
-	  var watcher
-	  for (i in this._userWatchers) {
-	    watcher = this._userWatchers[i]
-	    if (watcher) {
-	      watcher.teardown()
-	    }
-	  }
-	  // remove reference to self on $el
-	  if (this.$el) {
-	    this.$el.__vue__ = null
-	  }
-	  // remove DOM element
-	  var self = this
-	  if (remove && this.$el) {
-	    this.$remove(function () {
-	      self._cleanup()
-	    })
-	  } else if (!deferCleanup) {
-	    this._cleanup()
-	  }
+
+	exports.before = function (el, target) {
+	  target.parentNode.insertBefore(el, target)
 	}
-	
+
 	/**
-	 * Clean up to ensure garbage collection.
-	 * This is called after the leave transition if there
-	 * is any.
+	 * Insert el after target
+	 *
+	 * @param {Element} el
+	 * @param {Element} target
 	 */
-	
-	exports._cleanup = function () {
-	  // remove reference from data ob
-	  this._data.__ob__.removeVm(this)
-	  this._data =
-	  this._watchers =
-	  this._userWatchers =
-	  this._watcherList =
-	  this.$el =
-	  this.$parent =
-	  this.$root =
-	  this._children =
-	  this._transCpnts =
-	  this._directives = null
-	  // call the last hook...
-	  this._isDestroyed = true
-	  this._callHook('destroyed')
-	  // turn off all instance listeners.
-	  this.$off()
-	}
 
-/***/ },
-/* 6 */
-/***/ function(module, exports, __webpack_require__) {
+	exports.after = function (el, target) {
+	  if (target.nextSibling) {
+	    exports.before(el, target.nextSibling)
+	  } else {
+	    target.parentNode.appendChild(el)
+	  }
+	}
 
-	var _ = __webpack_require__(11)
-	var Watcher = __webpack_require__(25)
-	var Path = __webpack_require__(18)
-	var textParser = __webpack_require__(19)
-	var dirParser = __webpack_require__(21)
-	var expParser = __webpack_require__(22)
-	var filterRE = /[^|]\|[^|]/
-	
 	/**
-	 * Get the value from an expression on this vm.
+	 * Remove el from DOM
 	 *
-	 * @param {String} exp
-	 * @return {*}
+	 * @param {Element} el
 	 */
-	
-	exports.$get = function (exp) {
-	  var res = expParser.parse(exp)
-	  if (res) {
-	    return res.get.call(this, this)
-	  }
+
+	exports.remove = function (el) {
+	  el.parentNode.removeChild(el)
 	}
-	
+
 	/**
-	 * Set the value from an expression on this vm.
-	 * The expression must be a valid left-hand
-	 * expression in an assignment.
+	 * Prepend el to target
 	 *
-	 * @param {String} exp
-	 * @param {*} val
+	 * @param {Element} el
+	 * @param {Element} target
 	 */
-	
-	exports.$set = function (exp, val) {
-	  var res = expParser.parse(exp, true)
-	  if (res && res.set) {
-	    res.set.call(this, this, val)
+
+	exports.prepend = function (el, target) {
+	  if (target.firstChild) {
+	    exports.before(el, target.firstChild)
+	  } else {
+	    target.appendChild(el)
 	  }
 	}
-	
+
 	/**
-	 * Add a property on the VM
+	 * Replace target with el
 	 *
-	 * @param {String} key
-	 * @param {*} val
+	 * @param {Element} target
+	 * @param {Element} el
 	 */
-	
-	exports.$add = function (key, val) {
-	  this._data.$add(key, val)
+
+	exports.replace = function (target, el) {
+	  var parent = target.parentNode
+	  if (parent) {
+	    parent.replaceChild(el, target)
+	  }
 	}
-	
+
 	/**
-	 * Delete a property on the VM
+	 * Add event listener shorthand.
 	 *
-	 * @param {String} key
+	 * @param {Element} el
+	 * @param {String} event
+	 * @param {Function} cb
 	 */
-	
-	exports.$delete = function (key) {
-	  this._data.$delete(key)
+
+	exports.on = function (el, event, cb) {
+	  el.addEventListener(event, cb)
 	}
-	
+
 	/**
-	 * Watch an expression, trigger callback when its
-	 * value changes.
+	 * Remove event listener shorthand.
 	 *
-	 * @param {String} exp
+	 * @param {Element} el
+	 * @param {String} event
 	 * @param {Function} cb
-	 * @param {Boolean} [deep]
-	 * @param {Boolean} [immediate]
-	 * @return {Function} - unwatchFn
 	 */
-	
-	exports.$watch = function (exp, cb, deep, immediate) {
-	  var vm = this
-	  var key = deep ? exp + '**deep**' : exp
-	  var watcher = vm._userWatchers[key]
-	  var wrappedCb = function (val, oldVal) {
-	    cb.call(vm, val, oldVal)
-	  }
-	  if (!watcher) {
-	    watcher = vm._userWatchers[key] =
-	      new Watcher(vm, exp, wrappedCb, {
-	        deep: deep,
-	        user: true
-	      })
-	  } else {
-	    watcher.addCb(wrappedCb)
-	  }
-	  if (immediate) {
-	    wrappedCb(watcher.value)
-	  }
-	  return function unwatchFn () {
-	    watcher.removeCb(wrappedCb)
-	    if (!watcher.active) {
-	      vm._userWatchers[key] = null
-	    }
-	  }
+
+	exports.off = function (el, event, cb) {
+	  el.removeEventListener(event, cb)
 	}
-	
+
 	/**
-	 * Evaluate a text directive, including filters.
+	 * Add class with compatibility for IE & SVG
 	 *
-	 * @param {String} text
-	 * @return {String}
+	 * @param {Element} el
+	 * @param {Strong} cls
 	 */
-	
-	exports.$eval = function (text) {
-	  // check for filters.
-	  if (filterRE.test(text)) {
-	    var dir = dirParser.parse(text)[0]
-	    // the filter regex check might give false positive
-	    // for pipes inside strings, so it's possible that
-	    // we don't get any filters here
-	    return dir.filters
-	      ? _.applyFilters(
-	          this.$get(dir.expression),
-	          _.resolveFilters(this, dir.filters).read,
-	          this
-	        )
-	      : this.$get(dir.expression)
+
+	exports.addClass = function (el, cls) {
+	  if (el.classList) {
+	    el.classList.add(cls)
 	  } else {
-	    // no filter
-	    return this.$get(text)
+	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+	    if (cur.indexOf(' ' + cls + ' ') < 0) {
+	      el.setAttribute('class', (cur + cls).trim())
+	    }
 	  }
 	}
-	
+
 	/**
-	 * Interpolate a piece of template text.
+	 * Remove class with compatibility for IE & SVG
 	 *
-	 * @param {String} text
-	 * @return {String}
+	 * @param {Element} el
+	 * @param {Strong} cls
 	 */
-	
-	exports.$interpolate = function (text) {
-	  var tokens = textParser.parse(text)
-	  var vm = this
-	  if (tokens) {
-	    return tokens.length === 1
-	      ? vm.$eval(tokens[0].value)
-	      : tokens.map(function (token) {
-	          return token.tag
-	            ? vm.$eval(token.value)
-	            : token.value
-	        }).join('')
+
+	exports.removeClass = function (el, cls) {
+	  if (el.classList) {
+	    el.classList.remove(cls)
 	  } else {
-	    return text
+	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+	    var tar = ' ' + cls + ' '
+	    while (cur.indexOf(tar) >= 0) {
+	      cur = cur.replace(tar, ' ')
+	    }
+	    el.setAttribute('class', cur.trim())
 	  }
 	}
-	
+
 	/**
-	 * Log instance data as a plain JS object
-	 * so that it is easier to inspect in console.
-	 * This method assumes console is available.
+	 * Extract raw content inside an element into a temporary
+	 * container div
 	 *
-	 * @param {String} [path]
+	 * @param {Element} el
+	 * @param {Boolean} asFragment
+	 * @return {Element}
 	 */
-	
-	exports.$log = function (path) {
-	  var data = path
-	    ? Path.get(this._data, path)
-	    : this._data
-	  if (data) {
-	    data = JSON.parse(JSON.stringify(data))
+
+	exports.extractContent = function (el, asFragment) {
+	  var child
+	  var rawContent
+	  /* istanbul ignore if */
+	  if (
+	    el.tagName === 'TEMPLATE' &&
+	    el.content instanceof DocumentFragment
+	  ) {
+	    el = el.content
 	  }
-	  console.log(data)
+	  if (el.hasChildNodes()) {
+	    rawContent = asFragment
+	      ? document.createDocumentFragment()
+	      : document.createElement('div')
+	    /* jshint boss:true */
+	    while (child = el.firstChild) {
+	      rawContent.appendChild(child)
+	    }
+	  }
+	  return rawContent
 	}
 
+
 /***/ },
-/* 7 */
+/* 8 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var transition = __webpack_require__(49)
-	
+	var config = __webpack_require__(4)
+
 	/**
-	 * Append instance to target
-	 *
-	 * @param {Node} target
-	 * @param {Function} [cb]
-	 * @param {Boolean} [withTransition] - defaults to true
+	 * Enable debug utilities. The enableDebug() function and
+	 * all _.log() & _.warn() calls will be dropped in the
+	 * minified production build.
 	 */
-	
-	exports.$appendTo = function (target, cb, withTransition) {
-	  return insert(
-	    this, target, cb, withTransition,
-	    append, transition.append
-	  )
+
+	enableDebug()
+
+	function enableDebug () {
+
+	  var hasConsole = typeof console !== 'undefined'
+	  
+	  /**
+	   * Log a message.
+	   *
+	   * @param {String} msg
+	   */
+
+	  exports.log = function (msg) {
+	    if (hasConsole && config.debug) {
+	      console.log('[Vue info]: ' + msg)
+	    }
+	  }
+
+	  /**
+	   * We've got a problem here.
+	   *
+	   * @param {String} msg
+	   */
+
+	  exports.warn = function (msg) {
+	    if (hasConsole && (!config.silent || config.debug)) {
+	      console.warn('[Vue warn]: ' + msg)
+	      /* istanbul ignore if */
+	      if (config.debug) {
+	        /* jshint debug: true */
+	        debugger
+	      }
+	    }
+	  }
+
+	  /**
+	   * Assert asset exists
+	   */
+
+	  exports.assertAsset = function (val, type, id) {
+	    /* istanbul ignore if */
+	    if (type === 'directive') {
+	      if (id === 'component') {
+	        exports.warn(
+	          'v-component has been deprecated in 0.12. ' +
+	          'Use custom element syntax instead.'
+	        )
+	        return
+	      }
+	      if (id === 'with') {
+	        exports.warn(
+	          'v-with has been deprecated in 0.12. ' +
+	          'Use props instead.'
+	        )
+	        return
+	      }
+	    }
+	    if (!val) {
+	      exports.warn('Failed to resolve ' + type + ': ' + id)
+	    }
+	  }
 	}
-	
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var extend = _.extend
+
 	/**
-	 * Prepend instance to target
+	 * Option overwriting strategies are functions that handle
+	 * how to merge a parent option value and a child option
+	 * value into the final value.
 	 *
-	 * @param {Node} target
-	 * @param {Function} [cb]
-	 * @param {Boolean} [withTransition] - defaults to true
+	 * All strategy functions follow the same signature:
+	 *
+	 * @param {*} parentVal
+	 * @param {*} childVal
+	 * @param {Vue} [vm]
 	 */
-	
-	exports.$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
-	}
-	
+
+	var strats = Object.create(null)
+
 	/**
-	 * Insert instance before target
-	 *
-	 * @param {Node} target
-	 * @param {Function} [cb]
-	 * @param {Boolean} [withTransition] - defaults to true
+	 * Helper that recursively merges two data objects together.
 	 */
-	
-	exports.$before = function (target, cb, withTransition) {
-	  return insert(
-	    this, target, cb, withTransition,
-	    before, transition.before
-	  )
+
+	function mergeData (to, from) {
+	  var key, toVal, fromVal
+	  for (key in from) {
+	    toVal = to[key]
+	    fromVal = from[key]
+	    if (!to.hasOwnProperty(key)) {
+	      to.$add(key, fromVal)
+	    } else if (_.isObject(toVal) && _.isObject(fromVal)) {
+	      mergeData(toVal, fromVal)
+	    }
+	  }
+	  return to
 	}
-	
+
 	/**
-	 * Insert instance after target
-	 *
-	 * @param {Node} target
-	 * @param {Function} [cb]
-	 * @param {Boolean} [withTransition] - defaults to true
+	 * Data
 	 */
-	
-	exports.$after = function (target, cb, withTransition) {
-	  target = query(target)
-	  if (target.nextSibling) {
-	    this.$before(target.nextSibling, cb, withTransition)
+
+	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') {
+	      _.warn(
+	        'The "data" option should be a function ' +
+	        'that returns a per-instance value in component ' +
+	        'definitions.'
+	      )
+	      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 {
-	    this.$appendTo(target.parentNode, cb, withTransition)
+	    // instance merge, return raw object
+	    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
+	    }
 	  }
-	  return this
 	}
-	
+
 	/**
-	 * Remove instance from DOM
-	 *
-	 * @param {Function} [cb]
-	 * @param {Boolean} [withTransition] - defaults to true
+	 * El
 	 */
-	
-	exports.$remove = function (cb, withTransition) {
-	  var inDoc = this._isAttached && _.inDoc(this.$el)
-	  // if we are not in document, no need to check
-	  // for transitions
-	  if (!inDoc) withTransition = false
-	  var op
-	  var self = this
-	  var realCb = function () {
-	    if (inDoc) self._callHook('detached')
-	    if (cb) cb()
-	  }
-	  if (
-	    this._isBlock &&
-	    !this._blockFragment.hasChildNodes()
-	  ) {
-	    op = withTransition === false
-	      ? append
-	      : transition.removeThenAppend
-	    blockOp(this, this._blockFragment, op, realCb)
-	  } else {
-	    op = withTransition === false
-	      ? remove
-	      : transition.remove
-	    op(this.$el, this, realCb)
+
+	strats.el = function (parentVal, childVal, vm) {
+	  if (!vm && childVal && typeof childVal !== 'function') {
+	    _.warn(
+	      'The "el" option should be a function ' +
+	      'that returns a per-instance value in component ' +
+	      'definitions.'
+	    )
+	    return
 	  }
-	  return this
+	  var ret = childVal || parentVal
+	  // invoke the element factory if this is instance merge
+	  return vm && typeof ret === 'function'
+	    ? ret.call(vm)
+	    : ret
 	}
-	
+
 	/**
-	 * 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._isBlock) {
-	    blockOp(vm, target, op, cb)
-	  } else {
-	    op(vm.$el, target, vm, cb)
-	  }
-	  if (shouldCallHook) {
-	    vm._callHook('attached')
-	  }
-	  return vm
-	}
-	
-	/**
-	 * Execute a transition operation on a block instance,
-	 * iterating through all its block nodes.
-	 *
-	 * @param {Vue} vm
-	 * @param {Node} target
-	 * @param {Function} op
-	 * @param {Function} cb
+	 * Hooks and param attributes are merged as arrays.
 	 */
-	
-	function blockOp (vm, target, op, cb) {
-	  var current = vm._blockStart
-	  var end = vm._blockEnd
-	  var next
-	  while (next !== end) {
-	    next = current.nextSibling
-	    op(current, target, vm)
-	    current = next
-	  }
-	  op(end, target, vm, cb)
+
+	strats.created =
+	strats.ready =
+	strats.attached =
+	strats.detached =
+	strats.beforeCompile =
+	strats.compiled =
+	strats.beforeDestroy =
+	strats.destroyed =
+	strats.props = function (parentVal, childVal) {
+	  return childVal
+	    ? parentVal
+	      ? parentVal.concat(childVal)
+	      : _.isArray(childVal)
+	        ? childVal
+	        : [childVal]
+	    : parentVal
 	}
-	
+
 	/**
-	 * Check for selectors
-	 *
-	 * @param {String|Element} el
+	 * 0.11 deprecation warning
 	 */
-	
-	function query (el) {
-	  return typeof el === 'string'
-	    ? document.querySelector(el)
-	    : el
+
+	strats.paramAttributes = function () {
+	  /* istanbul ignore next */
+	  _.warn(
+	    '"paramAttributes" option has been deprecated in 0.12. ' +
+	    'Use "props" instead.'
+	  )
 	}
-	
+
 	/**
-	 * Append operation that takes a callback.
+	 * Assets
 	 *
-	 * @param {Node} el
-	 * @param {Node} target
-	 * @param {Vue} vm - unused
-	 * @param {Function} [cb]
+	 * When a vm is present (instance creation), we need to do
+	 * a three-way merge between constructor options, instance
+	 * options and parent options.
 	 */
-	
-	function append (el, target, vm, cb) {
-	  target.appendChild(el)
-	  if (cb) cb()
+
+	strats.directives =
+	strats.filters =
+	strats.transitions =
+	strats.components =
+	strats.elementDirectives = function (parentVal, childVal) {
+	  var res = Object.create(parentVal)
+	  return childVal
+	    ? extend(res, childVal)
+	    : res
 	}
-	
+
 	/**
-	 * InsertBefore operation that takes a callback.
+	 * Events & Watchers.
 	 *
-	 * @param {Node} el
-	 * @param {Node} target
-	 * @param {Vue} vm - unused
-	 * @param {Function} [cb]
+	 * Events & watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
 	 */
-	
-	function before (el, target, vm, cb) {
-	  _.before(el, target)
-	  if (cb) cb()
+
+	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
 	}
-	
+
 	/**
-	 * Remove operation that takes a callback.
-	 *
-	 * @param {Node} el
-	 * @param {Vue} vm - unused
-	 * @param {Function} [cb]
+	 * Other object hashes.
 	 */
-	
-	function remove (el, vm, cb) {
-	  _.remove(el)
-	  if (cb) cb()
-	}
 
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
+	strats.methods =
+	strats.computed = function (parentVal, childVal) {
+	  if (!childVal) return parentVal
+	  if (!parentVal) return childVal
+	  var ret = Object.create(parentVal)
+	  extend(ret, childVal)
+	  return ret
+	}
 
-	var _ = __webpack_require__(11)
-	
 	/**
-	 * Listen on the given `event` with `fn`.
-	 *
-	 * @param {String} event
-	 * @param {Function} fn
+	 * Default strategy.
 	 */
-	
-	exports.$on = function (event, fn) {
-	  (this._events[event] || (this._events[event] = []))
-	    .push(fn)
-	  modifyListenerCount(this, event, 1)
-	  return this
+
+	var defaultStrat = function (parentVal, childVal) {
+	  return childVal === undefined
+	    ? parentVal
+	    : childVal
 	}
-	
+
 	/**
-	 * Adds an `event` listener that will be invoked a single
-	 * time then automatically removed.
+	 * Make sure component options get converted to actual
+	 * constructors.
 	 *
-	 * @param {String} event
-	 * @param {Function} fn
+	 * @param {Object} components
 	 */
-	
-	exports.$once = function (event, fn) {
-	  var self = this
-	  function on () {
-	    self.$off(event, on)
-	    fn.apply(this, arguments)
+
+	function guardComponents (components) {
+	  if (components) {
+	    var def
+	    for (var key in components) {
+	      def = components[key]
+	      if (_.isPlainObject(def)) {
+	        def.name = key
+	        components[key] = _.Vue.extend(def)
+	      }
+	    }
 	  }
-	  on.fn = fn
-	  this.$on(event, on)
-	  return this
 	}
-	
+
 	/**
-	 * Remove the given callback for `event` or all
-	 * registered callbacks.
+	 * Merge two option objects into a new one.
+	 * Core utility used in both instantiation and inheritance.
 	 *
-	 * @param {String} event
-	 * @param {Function} fn
+	 * @param {Object} parent
+	 * @param {Object} child
+	 * @param {Vue} [vm] - if vm is present, indicates this is
+	 *                     an instantiation merge.
 	 */
-	
-	exports.$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)
-	        }
-	      }
+
+	exports.mergeOptions = function merge (parent, child, vm) {
+	  guardComponents(child.components)
+	  var options = {}
+	  var key
+	  if (child.mixins) {
+	    for (var i = 0, l = child.mixins.length; i < l; i++) {
+	      parent = merge(parent, child.mixins[i], vm)
 	    }
-	    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
+	  for (key in parent) {
+	    mergeField(key)
 	  }
-	  // 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
+	  for (key in child) {
+	    if (!(parent.hasOwnProperty(key))) {
+	      mergeField(key)
 	    }
 	  }
-	  return this
+	  function mergeField (key) {
+	    var strat = strats[key] || defaultStrat
+	    options[key] = strat(parent[key], child[key], vm, key)
+	  }
+	  return options
 	}
-	
+
 	/**
-	 * Trigger an event on self.
+	 * Resolve an asset.
+	 * This function is used because child instances need access
+	 * to assets defined in its ancestor chain.
 	 *
-	 * @param {String} event
+	 * @param {Object} options
+	 * @param {String} type
+	 * @param {String} id
+	 * @return {Object|Function}
 	 */
-	
-	exports.$emit = function (event) {
-	  this._eventCancelled = false
-	  var cbs = this._events[event]
-	  if (cbs) {
-	    // avoid leaking arguments:
-	    // http://jsperf.com/closure-with-arguments
-	    var i = arguments.length - 1
-	    var args = new Array(i)
-	    while (i--) {
-	      args[i] = arguments[i + 1]
-	    }
-	    i = 0
-	    cbs = cbs.length > 1
-	      ? _.toArray(cbs)
-	      : cbs
-	    for (var l = cbs.length; i < l; i++) {
-	      if (cbs[i].apply(this, args) === false) {
-	        this._eventCancelled = true
+
+	exports.resolveAsset = function resolve (options, type, id) {
+	  var asset = options[type][id]
+	  while (!asset && options._parent) {
+	    options = options._parent.$options
+	    asset = options[type][id]
+	  }
+	  return asset
+	}
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var Watcher = __webpack_require__(11)
+	var textParser = __webpack_require__(20)
+	var expParser = __webpack_require__(16)
+
+	/**
+	 * 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 {String} name
+	 * @param {Node} el
+	 * @param {Vue} vm
+	 * @param {Object} descriptor
+	 *                 - {String} expression
+	 *                 - {String} [arg]
+	 *                 - {Array<Object>} [filters]
+	 * @param {Object} def - directive definition object
+	 * @param {Vue|undefined} host - transclusion host target
+	 * @constructor
+	 */
+
+	function Directive (name, el, vm, descriptor, def, host) {
+	  // public
+	  this.name = name
+	  this.el = el
+	  this.vm = vm
+	  // copy descriptor props
+	  this.raw = descriptor.raw
+	  this.expression = descriptor.expression
+	  this.arg = descriptor.arg
+	  this.filters = descriptor.filters
+	  // private
+	  this._descriptor = descriptor
+	  this._host = host
+	  this._locked = false
+	  this._bound = false
+	  // init
+	  this._bind(def)
+	}
+
+	var p = Directive.prototype
+
+	/**
+	 * Initialize the directive, mixin definition properties,
+	 * setup the watcher, call definition bind() and update()
+	 * if present.
+	 *
+	 * @param {Object} def
+	 */
+
+	p._bind = function (def) {
+	  if (this.name !== 'cloak' && this.el && this.el.removeAttribute) {
+	    this.el.removeAttribute(config.prefix + this.name)
+	  }
+	  if (typeof def === 'function') {
+	    this.update = def
+	  } else {
+	    _.extend(this, def)
+	  }
+	  this._watcherExp = this.expression
+	  this._checkDynamicLiteral()
+	  if (this.bind) {
+	    this.bind()
+	  }
+	  if (this._watcherExp &&
+	      (this.update || this.twoWay) &&
+	      (!this.isLiteral || this._isDynamicLiteral) &&
+	      !this._checkStatement()) {
+	    // wrapped updater for context
+	    var dir = this
+	    var update = this._update = this.update
+	      ? function (val, oldVal) {
+	          if (!dir._locked) {
+	            dir.update(val, oldVal)
+	          }
+	        }
+	      : function () {} // noop if no update is provided
+	    // pre-process hook called before the value is piped
+	    // through the filters. used in v-repeat.
+	    var preProcess = this._preProcess
+	      ? _.bind(this._preProcess, this)
+	      : null
+	    var watcher = this._watcher = new Watcher(
+	      this.vm,
+	      this._watcherExp,
+	      update, // callback
+	      {
+	        filters: this.filters,
+	        twoWay: this.twoWay,
+	        deep: this.deep,
+	        preProcess: preProcess
 	      }
+	    )
+	    if (this._initValue != null) {
+	      watcher.set(this._initValue)
+	    } else if (this.update) {
+	      this.update(watcher.value)
 	    }
 	  }
-	  return this
+	  this._bound = true
 	}
-	
+
 	/**
-	 * Recursively broadcast an event to all children instances.
+	 * check if this is a dynamic literal binding.
 	 *
-	 * @param {String} event
-	 * @param {...*} additional arguments
+	 * e.g. v-component="{{currentView}}"
 	 */
-	
-	exports.$broadcast = function (event) {
-	  // if no child has registered for this event,
-	  // then there's no need to broadcast.
-	  if (!this._eventsCount[event]) return
-	  var children = this._children
-	  for (var i = 0, l = children.length; i < l; i++) {
-	    var child = children[i]
-	    child.$emit.apply(child, arguments)
-	    if (!child._eventCancelled) {
-	      child.$broadcast.apply(child, arguments)
+
+	p._checkDynamicLiteral = function () {
+	  var expression = this.expression
+	  if (expression && this.isLiteral) {
+	    var tokens = textParser.parse(expression)
+	    if (tokens) {
+	      var exp = textParser.tokensToExp(tokens)
+	      this.expression = this.vm.$get(exp)
+	      this._watcherExp = exp
+	      this._isDynamicLiteral = true
 	    }
 	  }
-	  return this
 	}
-	
+
 	/**
-	 * Recursively propagate an event up the parent chain.
+	 * 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.
 	 *
-	 * @param {String} event
-	 * @param {...*} additional arguments
+	 * e.g. v-on="click: a++"
+	 *
+	 * @return {Boolean}
 	 */
-	
-	exports.$dispatch = function () {
-	  var parent = this.$parent
-	  while (parent) {
-	    parent.$emit.apply(parent, arguments)
-	    parent = parent._eventCancelled
-	      ? null
-	      : parent.$parent
+
+	p._checkStatement = function () {
+	  var expression = this.expression
+	  if (
+	    expression && this.acceptStatement &&
+	    !expParser.isSimplePath(expression)
+	  ) {
+	    var fn = expParser.parse(expression).get
+	    var vm = this.vm
+	    var handler = function () {
+	      fn.call(vm, vm)
+	    }
+	    if (this.filters) {
+	      handler = vm._applyFilters(handler, null, this.filters)
+	    }
+	    this.update(handler)
+	    return true
 	  }
-	  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.
+	 * Check for an attribute directive param, e.g. lazy
 	 *
-	 * @param {Vue} vm
-	 * @param {String} event
-	 * @param {Number} count
+	 * @param {String} name
+	 * @return {String}
 	 */
-	
-	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
+
+	p._checkParam = function (name) {
+	  var param = this.el.getAttribute(name)
+	  if (param !== null) {
+	    this.el.removeAttribute(name)
 	  }
+	  return param
 	}
 
-/***/ },
-/* 9 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	
 	/**
-	 * Create a child instance that prototypally inehrits
-	 * data on parent. To achieve that we create an intermediate
-	 * constructor with its prototype pointing to parent.
-	 *
-	 * @param {Object} opts
-	 * @param {Function} [BaseCtor]
-	 * @return {Vue}
-	 * @public
+	 * Teardown the watcher and call unbind.
 	 */
-	
-	exports.$addChild = function (opts, BaseCtor) {
-	  BaseCtor = BaseCtor || _.Vue
-	  opts = opts || {}
-	  var parent = this
-	  var ChildVue
-	  var inherit = opts.inherit !== undefined
-	    ? opts.inherit
-	    : BaseCtor.options.inherit
-	  if (inherit) {
-	    var ctors = parent._childCtors
-	    ChildVue = ctors[BaseCtor.cid]
-	    if (!ChildVue) {
-	      var optionName = BaseCtor.options.name
-	      var className = optionName
-	        ? _.classify(optionName)
-	        : 'VueComponent'
-	      ChildVue = new Function(
-	        'return function ' + className + ' (options) {' +
-	        'this.constructor = ' + className + ';' +
-	        'this._init(options) }'
-	      )()
-	      ChildVue.options = BaseCtor.options
-	      ChildVue.prototype = this
-	      ctors[BaseCtor.cid] = ChildVue
+
+	p._teardown = function () {
+	  if (this._bound) {
+	    this._bound = false
+	    if (this.unbind) {
+	      this.unbind()
 	    }
-	  } else {
-	    ChildVue = BaseCtor
+	    if (this._watcher) {
+	      this._watcher.teardown()
+	    }
+	    this.vm = this.el = this._watcher = null
 	  }
-	  opts._parent = parent
-	  opts._root = parent.$root
-	  var child = new ChildVue(opts)
-	  return child
 	}
 
-/***/ },
-/* 10 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var compile = __webpack_require__(16)
-	
 	/**
-	 * 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).
+	 * Set the corresponding value with the setter.
+	 * This should only be used in two-way directives
+	 * e.g. v-model.
 	 *
-	 * @param {Element|DocumentFragment|string} el
+	 * @param {*} value
 	 * @public
 	 */
-	
-	exports.$mount = function (el) {
-	  if (this._isCompiled) {
-	    _.warn('$mount() should be called only once.')
-	    return
-	  }
-	  if (!el) {
-	    el = document.createElement('div')
-	  } else if (typeof el === 'string') {
-	    var selector = el
-	    el = document.querySelector(el)
-	    if (!el) {
-	      _.warn('Cannot find element: ' + selector)
-	      return
-	    }
-	  }
-	  this._compile(el)
-	  this._isCompiled = true
-	  this._callHook('compiled')
-	  if (_.inDoc(this.$el)) {
-	    this._callHook('attached')
-	    this._initDOMHooks()
-	    ready.call(this)
-	  } else {
-	    this._initDOMHooks()
-	    this.$once('hook:attached', ready)
+
+	p.set = function (value) {
+	  if (this.twoWay) {
+	    this._withLock(function () {
+	      this._watcher.set(value)
+	    })
 	  }
-	  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.
-	 */
-	
-	exports.$destroy = function (remove, deferCleanup) {
-	  this._destroy(remove, deferCleanup)
 	}
-	
+
 	/**
-	 * Partially compile a piece of DOM and return a
-	 * decompile function.
+	 * Execute a function while preventing that function from
+	 * triggering updates on this directive instance.
 	 *
-	 * @param {Element|DocumentFragment} el
-	 * @return {Function}
+	 * @param {Function} fn
 	 */
-	
-	exports.$compile = function (el) {
-	  return compile(el, this.$options, true)(this, el)
+
+	p._withLock = function (fn) {
+	  var self = this
+	  self._locked = true
+	  fn.call(self)
+	  _.nextTick(function () {
+	    self._locked = false
+	  })
 	}
 
+	module.exports = Directive
+
 /***/ },
 /* 11 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var lang   = __webpack_require__(27)
-	var extend = lang.extend
-	
-	extend(exports, lang)
-	extend(exports, __webpack_require__(28))
-	extend(exports, __webpack_require__(29))
-	extend(exports, __webpack_require__(30))
-	extend(exports, __webpack_require__(31))
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var Observer = __webpack_require__(12)
+	var expParser = __webpack_require__(16)
+	var batcher = __webpack_require__(19)
+	var uid = 0
 
-/***/ },
-/* 12 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * 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} expression
+	 * @param {Function} cb
+	 * @param {Object} options
+	 *                 - {Array} filters
+	 *                 - {Boolean} twoWay
+	 *                 - {Boolean} deep
+	 *                 - {Boolean} user
+	 *                 - {Function} [preProcess]
+	 * @constructor
+	 */
 
-	// manipulation directives
-	exports.text       = __webpack_require__(32)
-	exports.html       = __webpack_require__(33)
-	exports.attr       = __webpack_require__(34)
-	exports.show       = __webpack_require__(35)
-	exports['class']   = __webpack_require__(36)
-	exports.el         = __webpack_require__(37)
-	exports.ref        = __webpack_require__(38)
-	exports.cloak      = __webpack_require__(39)
-	exports.style      = __webpack_require__(40)
-	exports.partial    = __webpack_require__(41)
-	exports.transition = __webpack_require__(42)
-	
-	// event listener directives
-	exports.on         = __webpack_require__(43)
-	exports.model      = __webpack_require__(51)
-	
-	// child vm directives
-	exports.component  = __webpack_require__(44)
-	exports.repeat     = __webpack_require__(45)
-	exports['if']      = __webpack_require__(46)
-	
-	// child vm communication directives
-	exports['with']    = __webpack_require__(47)
-	exports.events     = __webpack_require__(48)
+	function Watcher (vm, expression, cb, options) {
+	  this.vm = vm
+	  vm._watchers.push(this)
+	  this.expression = expression
+	  this.cb = cb
+	  this.id = ++uid // uid for batching
+	  this.active = true
+	  options = options || {}
+	  this.deep = !!options.deep
+	  this.user = !!options.user
+	  this.twoWay = !!options.twoWay
+	  this.filters = options.filters
+	  this.preProcess = options.preProcess
+	  this.deps = []
+	  this.newDeps = []
+	  // parse expression for getter/setter
+	  var res = expParser.parse(expression, options.twoWay)
+	  this.getter = res.get
+	  this.setter = res.set
+	  this.value = this.get()
+	}
 
-/***/ },
-/* 13 */
-/***/ function(module, exports, __webpack_require__) {
+	var p = Watcher.prototype
 
-	var _ = __webpack_require__(11)
-	
 	/**
-	 * Stringify value.
+	 * Add a dependency to this directive.
 	 *
-	 * @param {Number} indent
+	 * @param {Dep} dep
 	 */
-	
-	exports.json = {
-	  read: function (value, indent) {
-	    return typeof value === 'string'
-	      ? value
-	      : JSON.stringify(value, null, Number(indent) || 2)
-	  },
-	  write: function (value) {
-	    try {
-	      return JSON.parse(value)
-	    } catch (e) {
-	      return value
+
+	p.addDep = function (dep) {
+	  var newDeps = this.newDeps
+	  var old = this.deps
+	  if (_.indexOf(newDeps, dep) < 0) {
+	    newDeps.push(dep)
+	    var i = _.indexOf(old, dep)
+	    if (i < 0) {
+	      dep.addSub(this)
+	    } else {
+	      old[i] = null
 	    }
 	  }
 	}
-	
-	/**
-	 * 'abc' => 'Abc'
-	 */
-	
-	exports.capitalize = function (value) {
-	  if (!value && value !== 0) return ''
-	  value = value.toString()
-	  return value.charAt(0).toUpperCase() + value.slice(1)
-	}
-	
-	/**
-	 * 'abc' => 'ABC'
-	 */
-	
-	exports.uppercase = function (value) {
-	  return (value || value === 0)
-	    ? value.toString().toUpperCase()
-	    : ''
-	}
-	
+
 	/**
-	 * 'AbC' => 'abc'
+	 * Evaluate the getter, and re-collect dependencies.
 	 */
-	
-	exports.lowercase = function (value) {
-	  return (value || value === 0)
-	    ? value.toString().toLowerCase()
-	    : ''
+
+	p.get = function () {
+	  this.beforeGet()
+	  var vm = this.vm
+	  var value
+	  try {
+	    value = this.getter.call(vm, vm)
+	  } catch (e) {
+	    if (config.warnExpressionErrors) {
+	      _.warn(
+	        'Error when evaluating expression "' +
+	        this.expression + '":\n   ' + e
+	      )
+	    }
+	  }
+	  // "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 = vm._applyFilters(value, null, this.filters, false)
+	  }
+	  this.afterGet()
+	  return value
 	}
-	
+
 	/**
-	 * 12345 => $12,345.00
+	 * Set the corresponding value with the setter.
 	 *
-	 * @param {String} sign
+	 * @param {*} value
 	 */
-	
-	var digitsRE = /(\d{3})(?=\d)/g
-	
-	exports.currency = function (value, sign) {
-	  value = parseFloat(value)
-	  if (!isFinite(value) || (!value && value !== 0)) return ''
-	  sign = sign || '$'
-	  var s = Math.floor(Math.abs(value)).toString(),
-	    i = s.length % 3,
-	    h = i > 0
-	      ? (s.slice(0, i) + (s.length > 3 ? ',' : ''))
-	      : '',
-	    v = Math.abs(parseInt((value * 100) % 100, 10)),
-	    f = '.' + (v < 10 ? ('0' + v) : v)
-	  return (value < 0 ? '-' : '') +
-	    sign + h + s.slice(i).replace(digitsRE, '$1,') + f
+
+	p.set = function (value) {
+	  var vm = this.vm
+	  if (this.filters) {
+	    value = vm._applyFilters(
+	      value, this.value, this.filters, true)
+	  }
+	  try {
+	    this.setter.call(vm, vm, value)
+	  } catch (e) {
+	    if (config.warnExpressionErrors) {
+	      _.warn(
+	        'Error when evaluating setter "' +
+	        this.expression + '":\n   ' + e
+	      )
+	    }
+	  }
 	}
-	
+
 	/**
-	 * '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']
+	 * Prepare for dependency collection.
 	 */
-	
-	exports.pluralize = function (value) {
-	  var args = _.toArray(arguments, 1)
-	  return args.length > 1
-	    ? (args[value % 10 - 1] || args[args.length - 1])
-	    : (args[0] + (value === 1 ? '' : 's'))
+
+	p.beforeGet = function () {
+	  Observer.target = this
 	}
-	
+
 	/**
-	 * A special filter that takes a handler function,
-	 * wraps it so it only gets triggered on specific
-	 * keypresses. v-on only.
-	 *
-	 * @param {String} key
+	 * Clean up for dependency collection.
 	 */
-	
-	var keyCodes = {
-	  enter    : 13,
-	  tab      : 9,
-	  'delete' : 46,
-	  up       : 38,
-	  left     : 37,
-	  right    : 39,
-	  down     : 40,
-	  esc      : 27
-	}
-	
-	exports.key = function (handler, key) {
-	  if (!handler) return
-	  var code = keyCodes[key]
-	  if (!code) {
-	    code = parseInt(key, 10)
-	  }
-	  return function (e) {
-	    if (e.keyCode === code) {
-	      return handler.call(this, e)
+
+	p.afterGet = function () {
+	  Observer.target = null
+	  var i = this.deps.length
+	  while (i--) {
+	    var dep = this.deps[i]
+	    if (dep) {
+	      dep.removeSub(this)
 	    }
 	  }
+	  this.deps = this.newDeps
+	  this.newDeps = []
 	}
-	
-	// expose keycode hash
-	exports.key.keyCodes = keyCodes
-	
+
 	/**
-	 * Install special array filters
+	 * Subscriber interface.
+	 * Will be called when a dependency changes.
 	 */
-	
-	_.extend(exports, __webpack_require__(50))
-
-
-/***/ },
-/* 14 */
-/***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var extend = _.extend
-	
-	/**
-	 * 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 = 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 (!to.hasOwnProperty(key)) {
-	      to.$add(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') {
-	      _.warn(
-	        'The "data" option should be a function ' +
-	        'that returns a per-instance value in component ' +
-	        'definitions.'
-	      )
-	      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)
-	      )
-	    }
+	p.update = function () {
+	  if (!config.async || config.debug) {
+	    this.run()
 	  } else {
-	    // instance merge, return raw object
-	    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
-	    }
+	    batcher.push(this)
 	  }
 	}
-	
+
 	/**
-	 * El
+	 * Batcher job interface.
+	 * Will be called by the batcher.
 	 */
-	
-	strats.el = function (parentVal, childVal, vm) {
-	  if (!vm && childVal && typeof childVal !== 'function') {
-	    _.warn(
-	      'The "el" option should be a function ' +
-	      'that returns a per-instance value in component ' +
-	      'definitions.'
-	    )
-	    return
+
+	p.run = function () {
+	  if (this.active) {
+	    var value = this.get()
+	    if (
+	      value !== this.value ||
+	      Array.isArray(value) ||
+	      this.deep
+	    ) {
+	      var oldValue = this.value
+	      this.value = value
+	      this.cb(value, oldValue)
+	    }
 	  }
-	  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.created =
-	strats.ready =
-	strats.attached =
-	strats.detached =
-	strats.beforeCompile =
-	strats.compiled =
-	strats.beforeDestroy =
-	strats.destroyed =
-	strats.paramAttributes = 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.
+	 * Remove self from all dependencies' subcriber list.
 	 */
-	
-	strats.directives =
-	strats.filters =
-	strats.partials =
-	strats.transitions =
-	strats.components = function (parentVal, childVal, vm, key) {
-	  var ret = Object.create(
-	    vm && vm.$parent
-	      ? vm.$parent.$options[key]
-	      : _.Vue.options[key]
-	  )
-	  if (parentVal) {
-	    var keys = Object.keys(parentVal)
-	    var i = keys.length
-	    var field
+
+	p.teardown = function () {
+	  if (this.active) {
+	    // remove self from vm's watcher list
+	    // we can skip this if the vm if being destroyed
+	    // which can improve teardown performance.
+	    if (!this.vm._isBeingDestroyed) {
+	      this.vm._watchers.$remove(this)
+	    }
+	    var i = this.deps.length
 	    while (i--) {
-	      field = keys[i]
-	      ret[field] = parentVal[field]
+	      this.deps[i].removeSub(this)
 	    }
+	    this.active = false
+	    this.vm = this.cb = this.value = null
 	  }
-	  if (childVal) extend(ret, childVal)
-	  return ret
 	}
-	
+
+
 	/**
-	 * Events & Watchers.
+	 * Recrusively traverse an object to evoke all converted
+	 * getters, so that every nested property inside the object
+	 * is collected as a "deep" dependency.
 	 *
-	 * Events & watchers hashes should not overwrite one
-	 * another, so we merge them as arrays.
+	 * @param {Object} obj
 	 */
-	
-	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]
+
+	function traverse (obj) {
+	  var key, val, i
+	  for (key in obj) {
+	    val = obj[key]
+	    if (_.isArray(val)) {
+	      i = val.length
+	      while (i--) traverse(val[i])
+	    } else if (_.isObject(val)) {
+	      traverse(val)
 	    }
-	    ret[key] = parent
-	      ? parent.concat(child)
-	      : [child]
 	  }
-	  return ret
 	}
-	
+
+	module.exports = Watcher
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var Dep = __webpack_require__(13)
+	var arrayMethods = __webpack_require__(14)
+	var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+	__webpack_require__(15)
+
+	var uid = 0
+
 	/**
-	 * Other object hashes.
+	 * Type enums
 	 */
-	
-	strats.methods =
-	strats.computed = function (parentVal, childVal) {
-	  if (!childVal) return parentVal
-	  if (!parentVal) return childVal
-	  var ret = Object.create(parentVal)
-	  extend(ret, childVal)
-	  return ret
-	}
-	
+
+	var ARRAY  = 0
+	var OBJECT = 1
+
 	/**
-	 * Default strategy.
+	 * Augment an target Object or Array by intercepting
+	 * the prototype chain using __proto__
+	 *
+	 * @param {Object|Array} target
+	 * @param {Object} proto
 	 */
-	
-	var defaultStrat = function (parentVal, childVal) {
-	  return childVal === undefined
-	    ? parentVal
-	    : childVal
+
+	function protoAugment (target, src) {
+	  target.__proto__ = src
 	}
-	
+
 	/**
-	 * Make sure component options get converted to actual
-	 * constructors.
+	 * Augment an target Object or Array by defining
+	 * hidden properties.
 	 *
-	 * @param {Object} components
+	 * @param {Object|Array} target
+	 * @param {Object} proto
 	 */
-	
-	function guardComponents (components) {
-	  if (components) {
-	    var def
-	    for (var key in components) {
-	      def = components[key]
-	      if (_.isPlainObject(def)) {
-	        def.name = key
-	        components[key] = _.Vue.extend(def)
-	      }
-	    }
+
+	function copyAugment (target, src, keys) {
+	  var i = keys.length
+	  var key
+	  while (i--) {
+	    key = keys[i]
+	    _.define(target, key, src[key])
 	  }
 	}
-	
+
 	/**
-	 * Merge two option objects into a new one.
-	 * Core utility used in both instantiation and inheritance.
+	 * 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 {Object} parent
-	 * @param {Object} child
-	 * @param {Vue} [vm] - if vm is present, indicates this is
-	 *                     an instantiation merge.
+	 * @param {Array|Object} value
+	 * @param {Number} type
+	 * @constructor
 	 */
-	
-	module.exports = function mergeOptions (parent, child, vm) {
-	  guardComponents(child.components)
-	  var options = {}
-	  var key
-	  if (child.mixins) {
-	    for (var i = 0, l = child.mixins.length; i < l; i++) {
-	      parent = mergeOptions(parent, child.mixins[i], vm)
-	    }
-	  }
-	  for (key in parent) {
-	    merge(key)
-	  }
-	  for (key in child) {
-	    if (!(parent.hasOwnProperty(key))) {
-	      merge(key)
-	    }
-	  }
-	  function merge (key) {
-	    var strat = strats[key] || defaultStrat
-	    options[key] = strat(parent[key], child[key], vm, key)
+
+	function Observer (value, type) {
+	  this.id = ++uid
+	  this.value = value
+	  this.active = true
+	  this.deps = []
+	  _.define(value, '__ob__', this)
+	  if (type === ARRAY) {
+	    var augment = config.proto && _.hasProto
+	      ? protoAugment
+	      : copyAugment
+	    augment(value, arrayMethods, arrayKeys)
+	    this.observeArray(value)
+	  } else if (type === OBJECT) {
+	    this.walk(value)
 	  }
-	  return options
 	}
 
-/***/ },
-/* 15 */
-/***/ function(module, exports, __webpack_require__) {
+	Observer.target = null
+
+	var p = Observer.prototype
 
-	module.exports = {
-	
-	  /**
-	   * The prefix to look for when parsing directives.
-	   *
-	   * @type {String}
-	   */
-	
-	  prefix: 'v-',
-	
-	  /**
-	   * Whether to print debug messages.
-	   * Also enables stack trace for warnings.
-	   *
-	   * @type {Boolean}
-	   */
-	
-	  debug: false,
-	
-	  /**
-	   * Whether to suppress warnings.
-	   *
-	   * @type {Boolean}
-	   */
-	
-	  silent: false,
-	
-	  /**
-	   * Whether allow observer to alter data objects'
-	   * __proto__.
-	   *
-	   * @type {Boolean}
-	   */
-	
-	  proto: true,
-	
-	  /**
-	   * Whether to parse mustache tags in templates.
-	   *
-	   * @type {Boolean}
-	   */
-	
-	  interpolate: true,
-	
-	  /**
-	   * Whether to use async rendering.
-	   */
-	
-	  async: true,
-	
-	  /**
-	   * Whether to warn against errors caught when evaluating
-	   * expressions.
-	   */
-	
-	  warnExpressionErrors: true,
-	
-	  /**
-	   * Internal flag to indicate the delimiters have been
-	   * changed.
-	   *
-	   * @type {Boolean}
-	   */
-	
-	  _delimitersChanged: true,
-	
-	  /**
-	   * List of directives that are "terminal", i.e. handles
-	   * the compilation of its own content
-	   */
-	
-	  _terminalDirectives: [
-	    'repeat',
-	    'if',
-	    'component'
-	  ]
-	
-	}
-	
 	/**
-	 * Interpolation delimiters.
-	 * We need to mark the changed flag so that the text parser
-	 * knows it needs to recompile the regex.
+	 * 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.
 	 *
-	 * @type {Array<String>}
+	 * @param {*} value
+	 * @return {Observer|undefined}
+	 * @static
 	 */
-	
-	var delimiters = ['{{', '}}']
-	Object.defineProperty(module.exports, 'delimiters', {
-	  get: function () {
-	    return delimiters
-	  },
-	  set: function (val) {
-	    delimiters = val
-	    this._delimitersChanged = true
-	  }
-	})
 
-/***/ },
-/* 16 */
-/***/ function(module, exports, __webpack_require__) {
+	Observer.create = function (value) {
+	  if (
+	    value &&
+	    value.hasOwnProperty('__ob__') &&
+	    value.__ob__ instanceof Observer
+	  ) {
+	    return value.__ob__
+	  } else if (_.isArray(value)) {
+	    return new Observer(value, ARRAY)
+	  } else if (
+	    _.isPlainObject(value) &&
+	    !value._isVue // avoid Vue instance
+	  ) {
+	    return new Observer(value, OBJECT)
+	  }
+	}
 
-	var _ = __webpack_require__(11)
-	var config = __webpack_require__(15)
-	var textParser = __webpack_require__(19)
-	var dirParser = __webpack_require__(21)
-	var templateParser = __webpack_require__(20)
-	
-	module.exports = compile
-	
 	/**
-	 * Compile a template and return a reusable composite link
-	 * function, which recursively contains more link functions
-	 * inside. This top level compile function should only be
-	 * called on instance root nodes.
+	 * Walk through each property and convert them into
+	 * getter/setters. This method should only be called when
+	 * value type is Object. Properties prefixed with `$` or `_`
+	 * and accessor properties are ignored.
 	 *
-	 * @param {Element|DocumentFragment} el
-	 * @param {Object} options
-	 * @param {Boolean} partial
-	 * @param {Boolean} transcluded
-	 * @return {Function}
+	 * @param {Object} obj
 	 */
-	
-	function compile (el, options, partial, transcluded) {
-	  // link function for the node itself.
-	  var nodeLinkFn = options._asComponent && !partial
-	    ? compileRoot(el, options)
-	    : compileNode(el, options)
-	  // link function for the childNodes
-	  var childLinkFn =
-	    !(nodeLinkFn && nodeLinkFn.terminal) &&
-	    el.tagName !== 'SCRIPT' &&
-	    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
-	   * @return {Function|undefined}
-	   */
-	
-	  function compositeLinkFn (vm, el) {
-	    // save original directive count before linking
-	    // so we can capture the directives created during a
-	    // partial compilation.
-	    var originalDirCount = vm._directives.length
-	    var parentOriginalDirCount =
-	      vm.$parent && vm.$parent._directives.length
-	    // cache childNodes before linking parent, fix #657
-	    var childNodes = _.toArray(el.childNodes)
-	    // if this is a transcluded compile, linkers need to be
-	    // called in source scope, and the host needs to be
-	    // passed down.
-	    var source = transcluded ? vm.$parent : vm
-	    var host = transcluded ? vm : undefined
-	    // link
-	    if (nodeLinkFn) nodeLinkFn(source, el, host)
-	    if (childLinkFn) childLinkFn(source, childNodes, host)
-	
-	    var selfDirs = vm._directives.slice(originalDirCount)
-	    var parentDirs = vm.$parent &&
-	      vm.$parent._directives.slice(parentOriginalDirCount)
-	
-	    /**
-	     * The linker function returns an unlink function that
-	     * tearsdown all directives instances generated during
-	     * the process.
-	     *
-	     * @param {Boolean} destroying
-	     */
-	    return function unlink (destroying) {
-	      teardownDirs(vm, selfDirs, destroying)
-	      if (parentDirs) {
-	        teardownDirs(vm.$parent, parentDirs)
-	      }
+
+	p.walk = function (obj) {
+	  var keys = Object.keys(obj)
+	  var i = keys.length
+	  var key, prefix
+	  while (i--) {
+	    key = keys[i]
+	    prefix = key.charCodeAt(0)
+	    if (prefix !== 0x24 && prefix !== 0x5F) { // skip $ or _
+	      this.convert(key, obj[key])
 	    }
 	  }
-	
-	  // transcluded linkFns are terminal, because it takes
-	  // over the entire sub-tree.
-	  if (transcluded) {
-	    compositeLinkFn.terminal = true
-	  }
-	
-	  return compositeLinkFn
 	}
-	
+
 	/**
-	 * Teardown a subset of directives on a vm.
+	 * Try to carete an observer for a child value,
+	 * and if value is array, link dep to the array.
 	 *
-	 * @param {Vue} vm
-	 * @param {Array} dirs
-	 * @param {Boolean} destroying
+	 * @param {*} val
+	 * @return {Dep|undefined}
 	 */
-	
-	function teardownDirs (vm, dirs, destroying) {
-	  var i = dirs.length
+
+	p.observe = function (val) {
+	  return Observer.create(val)
+	}
+
+	/**
+	 * Observe a list of Array items.
+	 *
+	 * @param {Array} items
+	 */
+
+	p.observeArray = function (items) {
+	  var i = items.length
 	  while (i--) {
-	    dirs[i]._teardown()
-	    if (!destroying) {
-	      vm._directives.$remove(dirs[i])
-	    }
+	    this.observe(items[i])
 	  }
 	}
-	
+
 	/**
-	 * Compile the root element of a component. There are
-	 * 4 types of things to process here:
-	 * 
-	 * 1. paramAttributes on parent container (child scope)
-	 * 2. v-with on parent container (child scope)
-	 * 3. other attrs on parent container (parent scope)
-	 * 4. attrs on the component template root node, if
-	 *    replace:true (child scope)
-	 *
-	 * Also, if this is a block instance, we only need to
-	 * compile 1 & 2 here.
+	 * Convert a property into getter/setter so we can emit
+	 * the events when the property is accessed/changed.
 	 *
-	 * @param {Element} el
-	 * @param {Object} options
-	 * @return {Function}
+	 * @param {String} key
+	 * @param {*} val
 	 */
-	
-	function compileRoot (el, options) {
-	  var isBlock = el.nodeType === 11 // DocumentFragment
-	  var containerAttrs = options._containerAttrs
-	  var replacerAttrs = options._replacerAttrs
-	  var params = options.paramAttributes
-	  var paramsLinkFn, withLinkFn, parentLinkFn, replacerLinkFn
-	  // 1. paramAttributes
-	  paramsLinkFn = params
-	    ? compileParamAttributes(el, containerAttrs, params, options)
-	    : null
-	  // 2. v-with
-	  var withName = config.prefix + 'with'
-	  var withVal = containerAttrs && containerAttrs[withName]
-	  if (withVal) {
-	    containerAttrs[withName] = null
-	    withLinkFn = makeNodeLinkFn([{
-	      name: 'with',
-	      descriptors: dirParser.parse(withVal),
-	      def: options.directives['with']
-	    }])
-	  }
-	  if (!isBlock) {
-	    // 3. container attributes
-	    if (containerAttrs) {
-	      parentLinkFn = compileDirectives(containerAttrs, options)
-	    }
-	    if (replacerAttrs) {
-	      // 4. replacer attributes
-	      replacerLinkFn = compileDirectives(replacerAttrs, options)
-	    }
-	  }
-	  return function rootLinkFn (vm, el, host) {
-	    // explicitly passing null to paramAttributes and v-with
-	    // linkers because they don't need a real element
-	    if (paramsLinkFn) paramsLinkFn(vm, null)
-	    if (withLinkFn) withLinkFn(vm, null)
-	    if (parentLinkFn) parentLinkFn(vm.$parent, el, host)
-	    if (replacerLinkFn) replacerLinkFn(vm, el, host)
+
+	p.convert = function (key, val) {
+	  var ob = this
+	  var childOb = ob.observe(val)
+	  var dep = new Dep()
+	  if (childOb) {
+	    childOb.deps.push(dep)
 	  }
+	  Object.defineProperty(ob.value, key, {
+	    enumerable: true,
+	    configurable: true,
+	    get: function () {
+	      // Observer.target is a watcher whose getter is
+	      // currently being evaluated.
+	      if (ob.active && Observer.target) {
+	        Observer.target.addDep(dep)
+	      }
+	      return val
+	    },
+	    set: function (newVal) {
+	      if (newVal === val) return
+	      // remove dep from old value
+	      var oldChildOb = val && val.__ob__
+	      if (oldChildOb) {
+	        oldChildOb.deps.$remove(dep)
+	      }
+	      val = newVal
+	      // add dep to new value
+	      var newChildOb = ob.observe(newVal)
+	      if (newChildOb) {
+	        newChildOb.deps.push(dep)
+	      }
+	      dep.notify()
+	    }
+	  })
 	}
-	
+
 	/**
-	 * Compile a node and return a nodeLinkFn based on the
-	 * node type.
-	 *
-	 * @param {Node} node
-	 * @param {Object} options
-	 * @return {Function|null}
+	 * Notify change on all self deps on an observer.
+	 * This is called when a mutable value mutates. e.g.
+	 * when an Array's mutating methods are called, or an
+	 * Object's $add/$delete are called.
 	 */
-	
-	function compileNode (node, options) {
-	  var type = node.nodeType
-	  if (type === 1 && node.tagName !== 'SCRIPT') {
-	    return compileElement(node, options)
-	  } else if (type === 3 && config.interpolate && node.data.trim()) {
-	    return compileTextNode(node, options)
-	  } else {
-	    return null
+
+	p.notify = function () {
+	  var deps = this.deps
+	  for (var i = 0, l = deps.length; i < l; i++) {
+	    deps[i].notify()
 	  }
 	}
-	
+
 	/**
-	 * Compile an element and return a nodeLinkFn.
+	 * Add an owner vm, so that when $add/$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 {Element} el
-	 * @param {Object} options
-	 * @return {Function|null}
+	 * @param {Vue} vm
 	 */
-	
-	function compileElement (el, options) {
-	  if (checkTransclusion(el)) {
-	    // unwrap textNode
-	    if (el.hasAttribute('__vue__wrap')) {
-	      el = el.firstChild
-	    }
-	    return compile(el, options._parent.$options, true, true)
-	  }
-	  var linkFn, tag, component
-	  // check custom element component, but only on non-root
-	  if (!el.__vue__) {
-	    tag = el.tagName.toLowerCase()
-	    component =
-	      tag.indexOf('-') > 0 &&
-	      options.components[tag]
-	    if (component) {
-	      el.setAttribute(config.prefix + 'component', tag)
-	    }
-	  }
-	  if (component || el.hasAttributes()) {
-	    // check terminal direcitves
-	    linkFn = checkTerminalDirectives(el, options)
-	    // if not terminal, build normal link function
-	    if (!linkFn) {
-	      linkFn = compileDirectives(el, options)
-	    }
-	  }
-	  // if the element is a textarea, we need to interpolate
-	  // its content on initial render.
-	  if (el.tagName === 'TEXTAREA') {
-	    var realLinkFn = linkFn
-	    linkFn = function (vm, el) {
-	      el.value = vm.$interpolate(el.value)
-	      if (realLinkFn) realLinkFn(vm, el)
-	    }
-	    linkFn.terminal = true
-	  }
-	  return linkFn
+
+	p.addVm = function (vm) {
+	  (this.vms = this.vms || []).push(vm)
 	}
-	
+
 	/**
-	 * Compile a textNode and return a nodeLinkFn.
+	 * Remove an owner vm. This is called when the object is
+	 * swapped out as an instance's $data object.
 	 *
-	 * @param {TextNode} node
-	 * @param {Object} options
-	 * @return {Function|null} textNodeLinkFn
+	 * @param {Vue} vm
 	 */
-	
-	function compileTextNode (node, options) {
-	  var tokens = textParser.parse(node.data)
-	  if (!tokens) {
-	    return null
-	  }
-	  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)
+
+	p.removeVm = function (vm) {
+	  this.vms.$remove(vm)
 	}
-	
+
+	module.exports = Observer
+
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
 	/**
-	 * Process a single text token.
+	 * A dep is an observable that can have multiple
+	 * directives subscribing to it.
 	 *
-	 * @param {Object} token
-	 * @param {Object} options
-	 * @return {Node}
+	 * @constructor
 	 */
-	
-	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 if (token.partial) {
-	      el = document.createComment('v-partial')
-	      setTokenType('partial')
-	    } 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) {
-	    token.type = type
-	    token.def = options.directives[type]
-	    token.descriptor = dirParser.parse(token.value)[0]
-	  }
-	  return el
+
+	function Dep () {
+	  this.subs = []
 	}
-	
+
+	var p = Dep.prototype
+
 	/**
-	 * Build a function that processes a textNode.
+	 * Add a directive subscriber.
 	 *
-	 * @param {Array<Object>} tokens
-	 * @param {DocumentFragment} frag
+	 * @param {Directive} sub
 	 */
-	
-	function makeTextNodeLinkFn (tokens, frag) {
-	  return function textNodeLinkFn (vm, el) {
-	    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 = vm.$eval(value)
-	          if (token.html) {
-	            _.replace(node, templateParser.parse(value, true))
-	          } else {
-	            node.data = value
-	          }
-	        } else {
-	          vm._bindDir(token.type, node,
-	                      token.descriptor, token.def)
-	        }
-	      }
-	    }
-	    _.replace(el, fragClone)
-	  }
+
+	p.addSub = function (sub) {
+	  this.subs.push(sub)
 	}
-	
+
 	/**
-	 * Compile a node list and return a childLinkFn.
+	 * Remove a directive subscriber.
 	 *
-	 * @param {NodeList} nodeList
-	 * @param {Object} options
-	 * @return {Function|undefined}
+	 * @param {Directive} sub
 	 */
-	
-	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)
+
+	p.removeSub = function (sub) {
+	  this.subs.$remove(sub)
+	}
+
+	/**
+	 * Notify all subscribers of a new value.
+	 */
+
+	p.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()
 	  }
-	  return linkFns.length
-	    ? makeChildLinkFn(linkFns)
-	    : null
 	}
-	
+
+	module.exports = Dep
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var arrayProto = Array.prototype
+	var arrayMethods = Object.create(arrayProto)
+
 	/**
-	 * Make a child link function for a node's childNodes.
-	 *
-	 * @param {Array<Function>} linkFns
-	 * @return {Function} childLinkFn
+	 * Intercept mutating methods and emit events
 	 */
-	
-	function makeChildLinkFn (linkFns) {
-	  return function childLinkFn (vm, nodes, host) {
-	    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)
-	      }
-	      if (childrenLinkFn) {
-	        childrenLinkFn(vm, childNodes, host)
-	      }
+
+	;[
+	  'push',
+	  'pop',
+	  'shift',
+	  'unshift',
+	  'splice',
+	  'sort',
+	  'reverse'
+	]
+	.forEach(function (method) {
+	  // cache original method
+	  var original = arrayProto[method]
+	  _.define(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.notify()
+	    return result
+	  })
+	})
+
 	/**
-	 * Compile param attributes on a root element and return
-	 * a paramAttributes link function.
+	 * Swap the element at the given index with a new value
+	 * and emits corresponding event.
 	 *
-	 * @param {Element|DocumentFragment} el
-	 * @param {Object} attrs
-	 * @param {Array} paramNames
-	 * @param {Object} options
-	 * @return {Function} paramsLinkFn
+	 * @param {Number} index
+	 * @param {*} val
+	 * @return {*} - replaced element
 	 */
-	
-	function compileParamAttributes (el, attrs, paramNames, options) {
-	  var params = []
-	  var i = paramNames.length
-	  var name, value, param
-	  while (i--) {
-	    name = paramNames[i]
-	    if (/[A-Z]/.test(name)) {
-	      _.warn(
-	        'You seem to be using camelCase for a paramAttribute, ' +
-	        'but HTML doesn\'t differentiate between upper and ' +
-	        'lower case. You should use hyphen-delimited ' +
-	        'attribute names. For more info see ' +
-	        'http://vuejs.org/api/options.html#paramAttributes'
-	      )
-	    }
-	    value = attrs[name]
-	    if (value !== null) {
-	      param = {
-	        name: name,
-	        value: value
-	      }
-	      var tokens = textParser.parse(value)
-	      if (tokens) {
-	        if (el && el.nodeType === 1) {
-	          el.removeAttribute(name)
-	        }
-	        attrs[name] = null
-	        if (tokens.length > 1) {
-	          _.warn(
-	            'Invalid param attribute binding: "' +
-	            name + '="' + value + '"' +
-	            '\nDon\'t mix binding tags with plain text ' +
-	            'in param attribute bindings.'
-	          )
-	          continue
-	        } else {
-	          param.dynamic = true
-	          param.value = tokens[0].value
-	        }
-	      }
-	      params.push(param)
+
+	_.define(
+	  arrayProto,
+	  '$set',
+	  function $set (index, val) {
+	    if (index >= this.length) {
+	      this.length = index + 1
 	    }
+	    return this.splice(index, 1, val)[0]
 	  }
-	  return makeParamsLinkFn(params, options)
-	}
-	
+	)
+
 	/**
-	 * Build a function that applies param attributes to a vm.
+	 * Convenience method to remove the element at given index.
 	 *
-	 * @param {Array} params
-	 * @param {Object} options
-	 * @return {Function} paramsLinkFn
+	 * @param {Number} index
+	 * @param {*} val
 	 */
-	
-	var dataAttrRE = /^data-/
-	
-	function makeParamsLinkFn (params, options) {
-	  var def = options.directives['with']
-	  return function paramsLinkFn (vm, el) {
-	    var i = params.length
-	    var param, path
-	    while (i--) {
-	      param = params[i]
-	      // params could contain dashes, which will be
-	      // interpreted as minus calculations by the parser
-	      // so we need to wrap the path here
-	      path = _.camelize(param.name.replace(dataAttrRE, ''))
-	      if (param.dynamic) {
-	        // dynamic param attribtues are bound as v-with.
-	        // we can directly duck the descriptor here beacuse
-	        // param attributes cannot use expressions or
-	        // filters.
-	        vm._bindDir('with', el, {
-	          arg: path,
-	          expression: param.value
-	        }, def)
-	      } else {
-	        // just set once
-	        vm.$set(path, param.value)
-	      }
+
+	_.define(
+	  arrayProto,
+	  '$remove',
+	  function $remove (index) {
+	    /* istanbul ignore if */
+	    if (!this.length) return
+	    if (typeof index !== 'number') {
+	      index = _.indexOf(this, index)
+	    }
+	    if (index > -1) {
+	      this.splice(index, 1)
 	    }
 	  }
-	}
-	
+	)
+
+	module.exports = arrayMethods
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var objProto = Object.prototype
+
 	/**
-	 * Check an element for terminal directives in fixed order.
-	 * If it finds one, return a terminal link function.
+	 * Add a new property to an observed object
+	 * and emits corresponding event
 	 *
-	 * @param {Element} el
-	 * @param {Object} options
-	 * @return {Function} terminalLinkFn
+	 * @param {String} key
+	 * @param {*} val
+	 * @public
 	 */
-	
-	function checkTerminalDirectives (el, options) {
-	  if (_.attr(el, 'pre') !== null) {
-	    return skip
-	  }
-	  var value, dirName
-	  var dirs = config._terminalDirectives
-	  /* jshint boss: true */
-	  for (var i = 0, l = dirs.length; i < l; i++) {
-	    dirName = dirs[i]
-	    if ((value = _.attr(el, dirName)) !== null) {
-	      return makeTerminalNodeLinkFn(el, dirName, value, options)
+
+	_.define(
+	  objProto,
+	  '$add',
+	  function $add (key, val) {
+	    if (this.hasOwnProperty(key)) return
+	    var ob = this.__ob__
+	    if (!ob || _.isReserved(key)) {
+	      this[key] = val
+	      return
+	    }
+	    ob.convert(key, val)
+	    ob.notify()
+	    if (ob.vms) {
+	      var i = ob.vms.length
+	      while (i--) {
+	        var vm = ob.vms[i]
+	        vm._proxy(key)
+	        vm._digest()
+	      }
 	    }
 	  }
-	}
-	
-	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.
+	 * Set a property on an observed object, calling add to
+	 * ensure the property is observed.
 	 *
-	 * @param {Element} el
-	 * @param {String} dirName
-	 * @param {String} value
-	 * @param {Object} options
-	 * @return {Function} terminalLinkFn
+	 * @param {String} key
+	 * @param {*} val
+	 * @public
 	 */
-	
-	function makeTerminalNodeLinkFn (el, dirName, value, options) {
-	  var descriptor = dirParser.parse(value)[0]
-	  var def = options.directives[dirName]
-	  var fn = function terminalNodeLinkFn (vm, el, host) {
-	    vm._bindDir(dirName, el, descriptor, def, host)
+
+	_.define(
+	  objProto,
+	  '$set',
+	  function $set (key, val) {
+	    this.$add(key, val)
+	    this[key] = val
 	  }
-	  fn.terminal = true
-	  return fn
-	}
-	
+	)
+
 	/**
-	 * Compile the directives on an element and return a linker.
+	 * Deletes a property from an observed object
+	 * and emits corresponding event
 	 *
-	 * @param {Element|Object} elOrAttrs
-	 *        - could be an object of already-extracted
-	 *          container attributes.
-	 * @param {Object} options
-	 * @return {Function}
+	 * @param {String} key
+	 * @public
 	 */
-	
-	function compileDirectives (elOrAttrs, options) {
-	  var attrs = _.isPlainObject(elOrAttrs)
-	    ? mapToList(elOrAttrs)
-	    : elOrAttrs.attributes
-	  var i = attrs.length
-	  var dirs = []
-	  var attr, name, value, dir, dirName, dirDef
-	  while (i--) {
-	    attr = attrs[i]
-	    name = attr.name
-	    value = attr.value
-	    if (value === null) continue
-	    if (name.indexOf(config.prefix) === 0) {
-	      dirName = name.slice(config.prefix.length)
-	      dirDef = options.directives[dirName]
-	      _.assertAsset(dirDef, 'directive', dirName)
-	      if (dirDef) {
-	        dirs.push({
-	          name: dirName,
-	          descriptors: dirParser.parse(value),
-	          def: dirDef
-	        })
-	      }
-	    } else if (config.interpolate) {
-	      dir = collectAttrDirective(name, value, options)
-	      if (dir) {
-	        dirs.push(dir)
-	      }
+
+	_.define(
+	  objProto,
+	  '$delete',
+	  function $delete (key) {
+	    if (!this.hasOwnProperty(key)) return
+	    delete this[key]
+	    var ob = this.__ob__
+	    if (!ob || _.isReserved(key)) {
+	      return
+	    }
+	    ob.notify()
+	    if (ob.vms) {
+	      var i = ob.vms.length
+	      while (i--) {
+	        var vm = ob.vms[i]
+	        vm._unproxy(key)
+	        vm._digest()
+	      }
 	    }
 	  }
-	  // sort by priority, LOW to HIGH
-	  if (dirs.length) {
-	    dirs.sort(directiveComparator)
-	    return makeNodeLinkFn(dirs)
-	  }
+	)
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var Path = __webpack_require__(17)
+	var Cache = __webpack_require__(18)
+	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,' +
+	  'proctected,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 pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
+	var booleanLiteralRE = /^(true|false)$/
+
+	/**
+	 * 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 + '"'
 	}
-	
+
 	/**
-	 * Convert a map (Object) of attributes to an Array.
+	 * Path rewrite replacer
 	 *
-	 * @param {Object} map
-	 * @return {Array}
+	 * @param {String} raw
+	 * @return {String}
 	 */
-	
-	function mapToList (map) {
-	  var list = []
-	  for (var key in map) {
-	    list.push({
-	      name: key,
-	      value: map[key]
-	    })
+
+	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
 	  }
-	  return list
 	}
-	
+
 	/**
-	 * Build a link function for all directives on a single node.
+	 * Restore replacer
 	 *
-	 * @param {Array} directives
-	 * @return {Function} directivesLinkFn
+	 * @param {String} str
+	 * @param {String} i - matched save index
+	 * @return {String}
 	 */
-	
-	function makeNodeLinkFn (directives) {
-	  return function nodeLinkFn (vm, el, host) {
-	    // reverse apply because it's sorted low to high
-	    var i = directives.length
-	    var dir, j, k
-	    while (i--) {
-	      dir = directives[i]
-	      if (dir._link) {
-	        // custom link fn
-	        dir._link(vm, el)
-	      } else {
-	        k = dir.descriptors.length
-	        for (j = 0; j < k; j++) {
-	          vm._bindDir(dir.name, el,
-	            dir.descriptors[j], dir.def, host)
-	        }
-	      }
-	    }
-	  }
+
+	function restore (str, i) {
+	  return saved[i]
 	}
-	
+
 	/**
-	 * Check an attribute for potential dynamic bindings,
-	 * and return a directive object.
+	 * Rewrite an expression, prefixing all path accessors with
+	 * `scope.` and generate getter/setter functions.
 	 *
-	 * @param {String} name
-	 * @param {String} value
-	 * @param {Object} options
-	 * @return {Object}
+	 * @param {String} exp
+	 * @param {Boolean} needSet
+	 * @return {Function}
 	 */
-	
-	function collectAttrDirective (name, value, options) {
-	  var tokens = textParser.parse(value)
-	  if (tokens) {
-	    var def = options.directives.attr
-	    var i = tokens.length
-	    var allOneTime = true
-	    while (i--) {
-	      var token = tokens[i]
-	      if (token.tag && !token.oneTime) {
-	        allOneTime = false
-	      }
-	    }
+
+	function compileExpFns (exp, needSet) {
+	  if (improperKeywordsRE.test(exp)) {
+	    _.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 becaue the regex matches 1 extra char
+	  body = (' ' + body)
+	    .replace(pathReplaceRE, rewrite)
+	    .replace(restoreRE, restore)
+	  var getter = makeGetter(body)
+	  if (getter) {
 	    return {
-	      def: def,
-	      _link: allOneTime
-	        ? function (vm, el) {
-	            el.setAttribute(name, vm.$interpolate(value))
-	          }
-	        : function (vm, el) {
-	            var value = textParser.tokensToExp(tokens, vm)
-	            var desc = dirParser.parse(name + ':' + value)[0]
-	            vm._bindDir('attr', el, desc, def)
-	          }
+	      get: getter,
+	      body: body,
+	      set: needSet
+	        ? makeSetter(body)
+	        : null
 	    }
 	  }
 	}
-	
+
 	/**
-	 * Directive priority sort comparator
+	 * Compile getter setters for a simple path.
 	 *
-	 * @param {Object} a
-	 * @param {Object} b
+	 * @param {String} exp
+	 * @return {Function}
 	 */
-	
-	function directiveComparator (a, b) {
-	  a = a.def.priority || 0
-	  b = b.def.priority || 0
-	  return a > b ? 1 : -1
+
+	function compilePathFns (exp) {
+	  var getter, path
+	  if (exp.indexOf('[') < 0) {
+	    // really simple path
+	    path = exp.split('.')
+	    path.raw = exp
+	    getter = Path.compileGetter(path)
+	  } else {
+	    // do the real parsing
+	    path = Path.parse(exp)
+	    getter = path.get
+	  }
+	  return {
+	    get: getter,
+	    // always generate setter for simple paths
+	    set: function (obj, val) {
+	      Path.set(obj, path, val)
+	    }
+	  }
 	}
-	
+
 	/**
-	 * Check whether an element is transcluded
+	 * Build a getter function. Requires eval.
 	 *
-	 * @param {Element} el
-	 * @return {Boolean}
+	 * 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}
 	 */
-	
-	var transcludedFlagAttr = '__vue__transcluded'
-	function checkTransclusion (el) {
-	  if (el.nodeType === 1 && el.hasAttribute(transcludedFlagAttr)) {
-	    el.removeAttribute(transcludedFlagAttr)
-	    return true
+
+	function makeGetter (body) {
+	  try {
+	    return new Function('scope', 'return ' + body + ';')
+	  } catch (e) {
+	    _.warn(
+	      'Invalid expression. ' +
+	      'Generated function body: ' + body
+	    )
 	  }
 	}
 
-/***/ },
-/* 17 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var templateParser = __webpack_require__(20)
-	var transcludedFlagAttr = '__vue__transcluded'
-	
 	/**
-	 * 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-repeat.
+	 * Build a setter function.
 	 *
-	 * @param {Element} el
-	 * @param {Object} options
-	 * @return {Element|DocumentFragment}
-	 */
-	
-	module.exports = function transclude (el, options) {
-	  if (options && options._asComponent) {
-	    // 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.
-	    options._containerAttrs = extractAttrs(el)
-	    // Mark content nodes and attrs so that the compiler
-	    // knows they should be compiled in parent scope.
-	    var i = el.childNodes.length
-	    while (i--) {
-	      var node = el.childNodes[i]
-	      if (node.nodeType === 1) {
-	        node.setAttribute(transcludedFlagAttr, '')
-	      } else if (node.nodeType === 3 && node.data.trim()) {
-	        // wrap transcluded textNodes in spans, because
-	        // raw textNodes can't be persisted through clones
-	        // by attaching attributes.
-	        var wrapper = document.createElement('span')
-	        wrapper.textContent = node.data
-	        wrapper.setAttribute('__vue__wrap', '')
-	        wrapper.setAttribute(transcludedFlagAttr, '')
-	        el.replaceChild(wrapper, node)
-	      }
-	    }
-	  }
-	  // for template tags, what we want is its content as
-	  // a documentFragment (for block instances)
-	  if (el.tagName === 'TEMPLATE') {
-	    el = templateParser.parse(el)
-	  }
-	  if (options && options.template) {
-	    el = transcludeTemplate(el, options)
-	  }
-	  if (el instanceof DocumentFragment) {
-	    _.prepend(document.createComment('v-start'), el)
-	    el.appendChild(document.createComment('v-end'))
-	  }
-	  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 = templateParser.parse(template, true)
-	  if (!frag) {
-	    _.warn('Invalid template option: ' + template)
-	  } else {
-	    var rawContent = options._content || _.extractContent(el)
-	    if (options.replace) {
-	      if (frag.childNodes.length > 1) {
-	        transcludeContent(frag, rawContent)
-	        return frag
-	      } else {
-	        var replacer = frag.firstChild
-	        options._replacerAttrs = extractAttrs(replacer)
-	        mergeAttrs(el, replacer)
-	        transcludeContent(replacer, rawContent)
-	        return replacer
-	      }
-	    } else {
-	      el.appendChild(frag)
-	      transcludeContent(el, rawContent)
-	      return el
-	    }
-	  }
-	}
-	
-	/**
-	 * Resolve <content> insertion points mimicking the behavior
-	 * of the Shadow DOM spec:
+	 * This is only needed in rare situations like "a[b]" where
+	 * a settable path requires dynamic evaluation.
 	 *
-	 *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
+	 * This setter function may throw error when called if the
+	 * expression body is not a valid left-hand expression in
+	 * assignment.
 	 *
-	 * @param {Element|DocumentFragment} el
-	 * @param {Element} raw
+	 * @param {String} body
+	 * @return {Function|undefined}
 	 */
-	
-	function transcludeContent (el, raw) {
-	  var outlets = getOutlets(el)
-	  var i = outlets.length
-	  if (!i) return
-	  var outlet, select, selected, j, main
-	
-	  function isDirectChild (node) {
-	    return node.parentNode === raw
-	  }
-	
-	  // first pass, collect corresponding content
-	  // for each outlet.
-	  while (i--) {
-	    outlet = outlets[i]
-	    if (raw) {
-	      select = outlet.getAttribute('select')
-	      if (select) {  // select content
-	        selected = raw.querySelectorAll(select)
-	        if (selected.length) {
-	          // according to Shadow DOM spec, `select` can
-	          // only select direct children of the host node.
-	          // enforcing this also fixes #786.
-	          selected = [].filter.call(selected, isDirectChild)
-	        }
-	        outlet.content = selected.length
-	          ? selected
-	          : _.toArray(outlet.childNodes)
-	      } else { // default content
-	        main = outlet
-	      }
-	    } else { // fallback content
-	      outlet.content = _.toArray(outlet.childNodes)
-	    }
-	  }
-	  // second pass, actually insert the contents
-	  for (i = 0, j = outlets.length; i < j; i++) {
-	    outlet = outlets[i]
-	    if (outlet !== main) {
-	      insertContentAt(outlet, outlet.content)
-	    }
-	  }
-	  // finally insert the main content
-	  if (main) {
-	    insertContentAt(main, _.toArray(raw.childNodes))
+
+	function makeSetter (body) {
+	  try {
+	    return new Function('scope', 'value', body + '=value;')
+	  } catch (e) {
+	    _.warn('Invalid setter function body: ' + body)
 	  }
 	}
-	
-	/**
-	 * Get <content> outlets from the element/list
-	 *
-	 * @param {Element|Array} el
-	 * @return {Array}
-	 */
-	
-	var concat = [].concat
-	function getOutlets (el) {
-	  return _.isArray(el)
-	    ? concat.apply([], el.map(getOutlets))
-	    : el.querySelectorAll
-	      ? _.toArray(el.querySelectorAll('content'))
-	      : []
-	}
-	
+
 	/**
-	 * Insert an array of nodes at outlet,
-	 * then remove the outlet.
+	 * Check for setter existence on a cache hit.
 	 *
-	 * @param {Element} outlet
-	 * @param {Array} contents
+	 * @param {Function} hit
 	 */
-	
-	function insertContentAt (outlet, contents) {
-	  // not using util DOM methods here because
-	  // parentNode can be cached
-	  var parent = outlet.parentNode
-	  for (var i = 0, j = contents.length; i < j; i++) {
-	    parent.insertBefore(contents[i], outlet)
+
+	function checkSetter (hit) {
+	  if (!hit.set) {
+	    hit.set = makeSetter(hit.body)
 	  }
-	  parent.removeChild(outlet)
 	}
-	
+
 	/**
-	 * Helper to extract a component container's attribute names
-	 * into a map. The resulting map will be used in compiler to
-	 * determine whether an attribute is transcluded.
+	 * Parse an expression into re-written getter/setters.
 	 *
-	 * @param {Element} el
+	 * @param {String} exp
+	 * @param {Boolean} needSet
+	 * @return {Function}
 	 */
-	
-	function extractAttrs (el) {
-	  var attrs = el.attributes
-	  if (!attrs) return
-	  var res = {}
-	  var i = attrs.length
-	  while (i--) {
-	    res[attrs[i].name] = attrs[i].value
+
+	exports.parse = function (exp, needSet) {
+	  exp = exp.trim()
+	  // try cache
+	  var hit = expressionCache.get(exp)
+	  if (hit) {
+	    if (needSet) {
+	      checkSetter(hit)
+	    }
+	    return hit
 	  }
+	  // we do a simple path check to optimize for them.
+	  // the check fails valid paths with unusal whitespaces,
+	  // but that's too rare and we don't care.
+	  // also skip boolean literals and paths that start with
+	  // global "Math"
+	  var res = exports.isSimplePath(exp)
+	    ? compilePathFns(exp)
+	    : compileExpFns(exp, needSet)
+	  expressionCache.put(exp, res)
 	  return res
 	}
-	
+
 	/**
-	 * Merge the attributes of two elements, and make sure
-	 * the class names are merged properly.
+	 * Check if an expression is a simple path.
 	 *
-	 * @param {Element} from
-	 * @param {Element} to
+	 * @param {String} exp
+	 * @return {Boolean}
 	 */
-	
-	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)) {
-	      to.setAttribute(name, value)
-	    } else if (name === 'class') {
-	      to.className = to.className + ' ' + value
-	    }
-	  }
+
+	exports.isSimplePath = function (exp) {
+	  return pathTestRE.test(exp) &&
+	    // don't treat true/false as paths
+	    !booleanLiteralRE.test(exp) &&
+	    // Math constants e.g. Math.PI, Math.E etc.
+	    exp.slice(0, 5) !== 'Math.'
 	}
 
 /***/ },
-/* 18 */
+/* 17 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var Cache = __webpack_require__(52)
+	var _ = __webpack_require__(2)
+	var Cache = __webpack_require__(18)
 	var pathCache = new Cache(1000)
-	var identRE = /^[$_a-zA-Z]+[\w$]*$/
-	
+	var identRE = exports.identRE = /^[$_a-zA-Z]+[\w$]*$/
+
 	/**
 	 * Path-parsing algorithm scooped from Polymer/observe-js
 	 */
-	
+
 	var pathStateMachine = {
 	  'beforePath': {
 	    'ws': ['beforePath'],
@@ -3117,19 +2637,19 @@ return /******/ (function(modules) { // webpackBootstrap
 	    '[': ['beforeElement'],
 	    'eof': ['afterPath']
 	  },
-	
+
 	  'inPath': {
 	    'ws': ['inPath'],
 	    '.': ['beforeIdent'],
 	    '[': ['beforeElement'],
 	    'eof': ['afterPath']
 	  },
-	
+
 	  'beforeIdent': {
 	    'ws': ['beforeIdent'],
 	    'ident': ['inIdent', 'append']
 	  },
-	
+
 	  'inIdent': {
 	    'ident': ['inIdent', 'append'],
 	    '0': ['inIdent', 'append'],
@@ -3137,63 +2657,65 @@ return /******/ (function(modules) { // webpackBootstrap
 	    'ws': ['inPath', 'push'],
 	    '.': ['beforeIdent', 'push'],
 	    '[': ['beforeElement', 'push'],
-	    'eof': ['afterPath', 'push']
+	    'eof': ['afterPath', 'push'],
+	    ']': ['inPath', 'push']
 	  },
-	
+
 	  'beforeElement': {
 	    'ws': ['beforeElement'],
 	    '0': ['afterZero', 'append'],
 	    'number': ['inIndex', 'append'],
 	    "'": ['inSingleQuote', 'append', ''],
-	    '"': ['inDoubleQuote', 'append', '']
+	    '"': ['inDoubleQuote', 'append', ''],
+	    "ident": ['inIdent', 'append', '*']
 	  },
-	
+
 	  'afterZero': {
 	    'ws': ['afterElement', 'push'],
 	    ']': ['inPath', 'push']
 	  },
-	
+
 	  'inIndex': {
 	    '0': ['inIndex', 'append'],
 	    'number': ['inIndex', 'append'],
 	    'ws': ['afterElement'],
 	    ']': ['inPath', 'push']
 	  },
-	
+
 	  'inSingleQuote': {
 	    "'": ['afterElement'],
 	    'eof': 'error',
 	    'else': ['inSingleQuote', 'append']
 	  },
-	
+
 	  'inDoubleQuote': {
 	    '"': ['afterElement'],
 	    'eof': 'error',
 	    'else': ['inDoubleQuote', 'append']
 	  },
-	
+
 	  'afterElement': {
 	    'ws': ['afterElement'],
 	    ']': ['inPath', 'push']
 	  }
 	}
-	
+
 	function noop () {}
-	
+
 	/**
 	 * Determine the type of a character in a keypath.
 	 *
 	 * @param {Char} char
 	 * @return {String} type
 	 */
-	
+
 	function getPathCharType (char) {
 	  if (char === undefined) {
 	    return 'eof'
 	  }
-	
+
 	  var code = char.charCodeAt(0)
-	
+
 	  switch(code) {
 	    case 0x5B: // [
 	    case 0x5D: // ]
@@ -3202,11 +2724,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	    case 0x27: // '
 	    case 0x30: // 0
 	      return char
-	
+
 	    case 0x5F: // _
 	    case 0x24: // $
 	      return 'ident'
-	
+
 	    case 0x20: // Space
 	    case 0x09: // Tab
 	    case 0x0A: // Newline
@@ -3217,21 +2739,21 @@ return /******/ (function(modules) { // webpackBootstrap
 	    case 0x2029:  // Paragraph Separator
 	      return 'ws'
 	  }
-	
+
 	  // a-z, A-Z
 	  if ((0x61 <= code && code <= 0x7A) ||
 	      (0x41 <= code && code <= 0x5A)) {
 	    return 'ident'
 	  }
-	
+
 	  // 1-9
 	  if (0x31 <= code && code <= 0x39) {
 	    return 'number'
 	  }
-	
+
 	  return 'else'
 	}
-	
+
 	/**
 	 * Parse a string path into an array of segments
 	 * Todo implement cache
@@ -3239,13 +2761,13 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {String} path
 	 * @return {Array|undefined}
 	 */
-	
+
 	function parsePath (path) {
 	  var keys = []
 	  var index = -1
 	  var mode = 'beforePath'
 	  var c, newChar, key, type, transition, action, typeMap
-	
+
 	  var actions = {
 	    push: function() {
 	      if (key === undefined) {
@@ -3262,7 +2784,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      }
 	    }
 	  }
-	
+
 	  function maybeUnescapeQuote () {
 	    var nextChar = path[index + 1]
 	    if ((mode === 'inSingleQuote' && nextChar === "'") ||
@@ -3273,53 +2795,59 @@ return /******/ (function(modules) { // webpackBootstrap
 	      return true
 	    }
 	  }
-	
+
 	  while (mode) {
 	    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]] || noop
-	    newChar = transition[2] === undefined
+	    newChar = transition[2]
+	    newChar = newChar === undefined
 	      ? c
-	      : transition[2]
+	      : newChar === '*'
+	        ? newChar + c
+	        : newChar
 	    action()
-	
+
 	    if (mode === 'afterPath') {
+	      keys.raw = path
 	      return keys
 	    }
 	  }
 	}
-	
+
 	/**
 	 * Format a accessor segment based on its type.
 	 *
 	 * @param {String} key
 	 * @return {Boolean}
 	 */
-	
-	function formatAccessor(key) {
+
+	function formatAccessor (key) {
 	  if (identRE.test(key)) { // identifier
 	    return '.' + key
 	  } else if (+key === key >>> 0) { // bracket index
 	    return '[' + key + ']'
+	  } else if (key.charAt(0) === '*') {
+	    return '[o' + formatAccessor(key.slice(1)) + ']'
 	  } else { // bracket string
 	    return '["' + key.replace(/"/g, '\\"') + '"]'
 	  }
 	}
-	
+
 	/**
 	 * Compiles a getter function with a fixed path.
 	 * The fixed path getter supresses errors.
@@ -3327,19 +2855,19 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {Array} path
 	 * @return {Function}
 	 */
-	
+
 	exports.compileGetter = function (path) {
 	  var body = 'return o' + path.map(formatAccessor).join('')
 	  return new Function('o', 'try {' + body + '} catch (e) {}')
 	}
-	
+
 	/**
 	 * External parse that check for a cache hit first
 	 *
 	 * @param {String} path
 	 * @return {Array|undefined}
 	 */
-	
+
 	exports.parse = function (path) {
 	  var hit = pathCache.get(path)
 	  if (!hit) {
@@ -3351,21 +2879,21 @@ return /******/ (function(modules) { // webpackBootstrap
 	  }
 	  return hit
 	}
-	
+
 	/**
 	 * Get from an object from a path string
 	 *
 	 * @param {Object} obj
 	 * @param {String} path
 	 */
-	
+
 	exports.get = function (obj, path) {
 	  path = exports.parse(path)
 	  if (path) {
 	    return path.get(obj)
 	  }
 	}
-	
+
 	/**
 	 * Set on an object from a path
 	 *
@@ -3373,8 +2901,9 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {String | Array} path
 	 * @param {*} val
 	 */
-	
+
 	exports.set = function (obj, path, val) {
+	  var original = obj
 	  if (typeof path === 'string') {
 	    path = exports.parse(path)
 	  }
@@ -3382,51 +2911,283 @@ return /******/ (function(modules) { // webpackBootstrap
 	    return false
 	  }
 	  var last, key
-	  for (var i = 0, l = path.length - 1; i < l; i++) {
+	  for (var i = 0, l = path.length; i < l; i++) {
 	    last = obj
 	    key = path[i]
-	    obj = obj[key]
-	    if (!_.isObject(obj)) {
-	      obj = {}
-	      last.$add(key, obj)
+	    if (key.charAt(0) === '*') {
+	      key = original[key.slice(1)]
+	    }
+	    if (i < l - 1) {
+	      obj = obj[key]
+	      if (!_.isObject(obj)) {
+	        obj = {}
+	        last.$add(key, obj)
+	        warnNonExistent(path)
+	      }
+	    } else {
+	      if (key in obj) {
+	        obj[key] = val
+	      } else {
+	        obj.$add(key, val)
+	        warnNonExistent(path)
+	      }
 	    }
 	  }
-	  key = path[i]
-	  if (key in obj) {
-	    obj[key] = val
+	  return true
+	}
+
+	function warnNonExistent (path) {
+	  _.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.'
+	  )
+	}
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * A doubly linked list-based Least Recently Used (LRU)
+	 * cache. Will keep most recently used items while
+	 * discarding least recently used items when its limit is
+	 * reached. This is a bare-bone version of
+	 * Rasmus Andersson's js-lru:
+	 *
+	 *   https://github.com/rsms/js-lru
+	 *
+	 * @param {Number} limit
+	 * @constructor
+	 */
+
+	function Cache (limit) {
+	  this.size = 0
+	  this.limit = limit
+	  this.head = this.tail = undefined
+	  this._keymap = {}
+	}
+
+	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 entry = {
+	    key:key,
+	    value:value
+	  }
+	  this._keymap[key] = entry
+	  if (this.tail) {
+	    this.tail.newer = entry
+	    entry.older = this.tail
 	  } else {
-	    obj.$add(key, val)
+	    this.head = entry
 	  }
-	  return true
+	  this.tail = entry
+	  if (this.size === this.limit) {
+	    return this.shift()
+	  } else {
+	    this.size++
+	  }
+	}
+
+	/**
+	 * 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
+	  }
+	  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
 	}
 
+	module.exports = Cache
+
 /***/ },
 /* 19 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var Cache = __webpack_require__(52)
-	var config = __webpack_require__(15)
+	var _ = __webpack_require__(2)
+	var MAX_UPDATE_COUNT = 10
+
+	// 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 waiting = false
+	var flushing = false
+
+	/**
+	 * Reset the batcher's state.
+	 */
+
+	function reset () {
+	  queue = []
+	  userQueue = []
+	  has = {}
+	  waiting = false
+	  flushing = false
+	}
+
+	/**
+	 * Flush both queues and run the jobs.
+	 */
+
+	function flush () {
+	  flushing = true
+	  run(queue)
+	  run(userQueue)
+	  reset()
+	}
+
+	/**
+	 * Run the jobs in a single queue.
+	 *
+	 * @param {Array} queue
+	 */
+
+	function run (queue) {
+	  // do not cache length because more jobs might be pushed
+	  // as we run existing jobs
+	  for (var i = 0; i < queue.length; i++) {
+	    queue[i].run()
+	  }
+	}
+
+	/**
+	 * Push a job into the job queue.
+	 * Jobs with duplicate IDs will be skipped unless it's
+	 * pushed when the queue is being flushed.
+	 *
+	 * @param {Object} job
+	 *   properties:
+	 *   - {String|Number} id
+	 *   - {Function}      run
+	 */
+
+	exports.push = function (job) {
+	  var id = job.id
+	  if (!id || !has[id] || flushing) {
+	    if (!has[id]) {
+	      has[id] = 1
+	    } else {
+	      has[id]++
+	      // detect possible infinite update loops
+	      if (has[id] > MAX_UPDATE_COUNT) {
+	        _.warn(
+	          'You may have an infinite update loop for the ' +
+	          'watcher with expression: "' + job.expression + '".'
+	        )
+	        return
+	      }
+	    }
+	    // A user watcher callback could trigger another
+	    // directive update during the flushing; at that time
+	    // the directive queue would already have been run, so
+	    // we call that update immediately as it is pushed.
+	    if (flushing && !job.user) {
+	      job.run()
+	      return
+	    }
+	    ;(job.user ? userQueue : queue).push(job)
+	    if (!waiting) {
+	      waiting = true
+	      _.nextTick(flush)
+	    }
+	  }
+	}
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var Cache = __webpack_require__(18)
+	var config = __webpack_require__(4)
 	var dirParser = __webpack_require__(21)
 	var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
 	var cache, tagRE, htmlRE, firstChar, lastChar
-	
+
 	/**
 	 * Escape a string so it can be used in a RegExp
 	 * constructor.
 	 *
 	 * @param {String} str
 	 */
-	
+
 	function escapeRegex (str) {
 	  return str.replace(regexEscapeRE, '\\$&')
 	}
-	
+
 	/**
 	 * Compile the interpolation tag regex.
 	 *
 	 * @return {RegExp}
 	 */
-	
+
 	function compileRegex () {
 	  config._delimitersChanged = false
 	  var open = config.delimiters[0]
@@ -3451,7 +3212,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  // reset cache
 	  cache = new Cache(1000)
 	}
-	
+
 	/**
 	 * Parse a template text string into an array of tokens.
 	 *
@@ -3462,7 +3223,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	 *               - {Boolean} [html]
 	 *               - {Boolean} [oneTime]
 	 */
-	
+
 	exports.parse = function (text) {
 	  if (config._delimitersChanged) {
 	    compileRegex()
@@ -3476,7 +3237,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  }
 	  var tokens = []
 	  var lastIndex = tagRE.lastIndex = 0
-	  var match, index, value, first, oneTime, partial
+	  var match, index, value, first, oneTime
 	  /* jshint boss:true */
 	  while (match = tagRE.exec(text)) {
 	    index = match.index
@@ -3489,16 +3250,14 @@ return /******/ (function(modules) { // webpackBootstrap
 	    // tag token
 	    first = match[1].charCodeAt(0)
 	    oneTime = first === 0x2A // *
-	    partial = first === 0x3E // >
-	    value = (oneTime || partial)
+	    value = oneTime
 	      ? match[1].slice(1)
 	      : match[1]
 	    tokens.push({
 	      tag: true,
 	      value: value.trim(),
 	      html: htmlRE.test(match[0]),
-	      oneTime: oneTime,
-	      partial: partial
+	      oneTime: oneTime
 	    })
 	    lastIndex = index + match[0].length
 	  }
@@ -3510,7 +3269,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  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
@@ -3520,7 +3279,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {Vue} [vm]
 	 * @return {String}
 	 */
-	
+
 	exports.tokensToExp = function (tokens, vm) {
 	  return tokens.length > 1
 	    ? tokens.map(function (token) {
@@ -3528,7 +3287,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      }).join('+')
 	    : formatToken(tokens[0], vm, true)
 	}
-	
+
 	/**
 	 * Format a single token.
 	 *
@@ -3537,17 +3296,15 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {Boolean} single
 	 * @return {String}
 	 */
-	
+
 	function formatToken (token, vm, single) {
 	  return token.tag
 	    ? vm && token.oneTime
 	      ? '"' + vm.$eval(token.value) + '"'
-	      : single
-	        ? token.value
-	        : inlineFilters(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
@@ -3557,312 +3314,45 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * to directive parser and watcher mechanism.
 	 *
 	 * @param {String} exp
+	 * @param {Boolean} single
 	 * @return {String}
 	 */
-	
+
 	var filterRE = /[^|]\|[^|]/
-	function inlineFilters (exp) {
+	function inlineFilters (exp, single) {
 	  if (!filterRE.test(exp)) {
-	    return '(' + exp + ')'
+	    return single
+	      ? exp
+	      : '(' + exp + ')'
 	  } else {
 	    var dir = dirParser.parse(exp)[0]
 	    if (!dir.filters) {
 	      return '(' + exp + ')'
 	    } else {
-	      exp = dir.expression
-	      for (var i = 0, l = dir.filters.length; i < l; i++) {
-	        var filter = dir.filters[i]
-	        var args = filter.args
-	          ? ',"' + filter.args.join('","') + '"'
-	          : ''
-	        filter = 'this.$options.filters["' + filter.name + '"]'
-	        exp = '(' + filter + '.read||' + filter + ')' +
-	          '.apply(this,[' + exp + args + '])'
-	      }
-	      return exp
+	      return 'this._applyFilters(' +
+	        dir.expression + // value
+	        ',null,' +       // oldValue (null for read)
+	        JSON.stringify(dir.filters) + // filter descriptors
+	        ',false)'        // write?
 	    }
 	  }
 	}
 
 /***/ },
-/* 20 */
+/* 21 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var Cache = __webpack_require__(52)
-	var templateCache = new Cache(1000)
-	var idSelectorCache = new Cache(1000)
-	
-	var map = {
-	  _default : [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>'
-	]
-	
-	var tagRE = /<([\w:]+)/
-	var entityRE = /&\w+;/
-	
-	/**
-	 * Convert a string template to a DocumentFragment.
-	 * Determines correct wrapping by tag types. Wrapping
-	 * strategy found in jQuery & component/domify.
-	 *
-	 * @param {String} templateString
-	 * @return {DocumentFragment}
-	 */
-	
-	function stringToFragment (templateString) {
-	  // try a cache hit first
-	  var hit = templateCache.get(templateString)
-	  if (hit) {
-	    return hit
-	  }
-	
-	  var frag = document.createDocumentFragment()
-	  var tagMatch = templateString.match(tagRE)
-	  var entityMatch = entityRE.test(templateString)
-	
-	  if (!tagMatch && !entityMatch) {
-	    // text only, return a single text node.
-	    frag.appendChild(
-	      document.createTextNode(templateString)
-	    )
-	  } else {
-	
-	    var tag    = tagMatch && tagMatch[1]
-	    var wrap   = map[tag] || map._default
-	    var depth  = wrap[0]
-	    var prefix = wrap[1]
-	    var suffix = wrap[2]
-	    var node   = document.createElement('div')
-	
-	    node.innerHTML = prefix + templateString.trim() + suffix
-	    while (depth--) {
-	      node = node.lastChild
-	    }
-	
-	    var child
-	    /* jshint boss:true */
-	    while (child = node.firstChild) {
-	      frag.appendChild(child)
-	    }
-	  }
-	
-	  templateCache.put(templateString, frag)
-	  return frag
-	}
-	
-	/**
-	 * Convert a template node to a DocumentFragment.
-	 *
-	 * @param {Node} node
-	 * @return {DocumentFragment}
-	 */
-	
-	function nodeToFragment (node) {
-	  var tag = node.tagName
-	  // if its a template tag and the browser supports it,
-	  // its content is already a document fragment.
-	  if (
-	    tag === 'TEMPLATE' &&
-	    node.content instanceof DocumentFragment
-	  ) {
-	    return node.content
-	  }
-	  // script template
-	  if (tag === 'SCRIPT') {
-	    return stringToFragment(node.textContent)
-	  }
-	  // normal node, clone it to avoid mutating the original
-	  var clone = exports.clone(node)
-	  var frag = document.createDocumentFragment()
-	  var child
-	  /* jshint boss:true */
-	  while (child = clone.firstChild) {
-	    frag.appendChild(child)
-	  }
-	  return frag
-	}
-	
-	// Test for the presence of the Safari template cloning bug
-	// https://bugs.webkit.org/show_bug.cgi?id=137755
-	var hasBrokenTemplate = _.inBrowser
-	  ? (function () {
-	      var a = document.createElement('div')
-	      a.innerHTML = '<template>1</template>'
-	      return !a.cloneNode(true).firstChild.innerHTML
-	    })()
-	  : false
-	
-	// Test for IE10/11 textarea placeholder clone bug
-	var hasTextareaCloneBug = _.inBrowser
-	  ? (function () {
-	      var t = document.createElement('textarea')
-	      t.placeholder = 't'
-	      return t.cloneNode(true).value === 't'
-	    })()
-	  : 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}
-	 */
-	
-	exports.clone = function (node) {
-	  var res = node.cloneNode(true)
-	  var i, original, cloned
-	  /* istanbul ignore if */
-	  if (hasBrokenTemplate) {
-	    original = node.querySelectorAll('template')
-	    if (original.length) {
-	      cloned = res.querySelectorAll('template')
-	      i = cloned.length
-	      while (i--) {
-	        cloned[i].parentNode.replaceChild(
-	          original[i].cloneNode(true),
-	          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} clone
-	 * @param {Boolean} noSelector
-	 * @return {DocumentFragment|undefined}
-	 */
-	
-	exports.parse = function (template, clone, noSelector) {
-	  var node, frag
-	
-	  // if the template is already a document fragment,
-	  // do nothing
-	  if (template instanceof DocumentFragment) {
-	    return clone
-	      ? template.cloneNode(true)
-	      : template
-	  }
-	
-	  if (typeof template === 'string') {
-	    // id selector
-	    if (!noSelector && 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)
-	    }
-	  } else if (template.nodeType) {
-	    // a direct node
-	    frag = nodeToFragment(template)
-	  }
-	
-	  return frag && clone
-	    ? exports.clone(frag)
-	    : frag
-	}
-
-/***/ },
-/* 21 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var Cache = __webpack_require__(52)
+	var _ = __webpack_require__(2)
+	var Cache = __webpack_require__(18)
 	var cache = new Cache(1000)
 	var argRE = /^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/
 	var filterTokenRE = /[^\s'"]+|'[^']+'|"[^"]+"/g
-	
+	var reservedArgRE = /^in$|^-?\d+/
+
 	/**
 	 * Parser state
 	 */
-	
+
 	var str
 	var c, i, l
 	var inSingle
@@ -3876,11 +3366,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	var dir
 	var lastFilterIndex
 	var arg
-	
+
 	/**
 	 * Push a directive object into the result Array
 	 */
-	
+
 	function pushDir () {
 	  dir.raw = str.slice(begin, i).trim()
 	  if (dir.expression === undefined) {
@@ -3892,11 +3382,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	    dirs.push(dir)
 	  }
 	}
-	
+
 	/**
 	 * Push a filter to the current directive object
 	 */
-	
+
 	function pushFilter () {
 	  var exp = str.slice(lastFilterIndex, i).trim()
 	  var filter
@@ -3904,14 +3394,33 @@ return /******/ (function(modules) { // webpackBootstrap
 	    filter = {}
 	    var tokens = exp.match(filterTokenRE)
 	    filter.name = tokens[0]
-	    filter.args = tokens.length > 1 ? tokens.slice(1) : null
+	    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) {
+	  var stripped = reservedArgRE.test(arg)
+	    ? arg
+	    : _.stripQuotes(arg)
+	  return {
+	    value: stripped || arg,
+	    dynamic: !stripped
+	  }
+	}
+
 	/**
 	 * Parse a directive string into an Array of AST-like
 	 * objects representing directives.
@@ -3930,14 +3439,14 @@ return /******/ (function(modules) { // webpackBootstrap
 	 * @param {String} str
 	 * @return {Array<Object>}
 	 */
-	
+
 	exports.parse = function (s) {
-	
+
 	  var hit = cache.get(s)
 	  if (hit) {
 	    return hit
 	  }
-	
+
 	  // reset parser state
 	  str = s
 	  inSingle = inDouble = false
@@ -3946,7 +3455,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  dirs = []
 	  dir = {}
 	  arg = null
-	
+
 	  for (i = 0, l = str.length; i < l; i++) {
 	    c = str.charCodeAt(i)
 	    if (inSingle) {
@@ -4004,11 +3513,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	      }
 	    }
 	  }
-	
+
 	  if (i === 0 || begin !== i) {
 	    pushDir()
 	  }
-	
+
 	  cache.put(s, dirs)
 	  return dirs
 	}
@@ -4017,2458 +3526,3186 @@ return /******/ (function(modules) { // webpackBootstrap
 /* 22 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var Path = __webpack_require__(18)
-	var Cache = __webpack_require__(52)
-	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,' +
-	  'proctected,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+\])*$/
-	var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
-	var booleanLiteralRE = /^(true|false)$/
-	
-	/**
-	 * 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 = []
-	
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var textParser = __webpack_require__(20)
+	var dirParser = __webpack_require__(21)
+	var templateParser = __webpack_require__(23)
+	var resolveAsset = _.resolveAsset
+
+	// internal directives
+	var propDef = __webpack_require__(24)
+	var componentDef = __webpack_require__(25)
+
+	// terminal directives
+	var terminalDirectives = [
+	  'repeat',
+	  'if'
+	]
+
+	module.exports = compile
+
 	/**
-	 * 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.
+	 * Compile a template and return a reusable composite link
+	 * function, which recursively contains more link functions
+	 * inside. This top level compile function should only be
+	 * called on instance root nodes.
 	 *
-	 * @param {String} str
-	 * @param {String} isString - str if matched as a string
-	 * @return {String} - placeholder with index
+	 * @param {Element|DocumentFragment} el
+	 * @param {Object} options
+	 * @param {Boolean} partial
+	 * @param {Boolean} transcluded
+	 * @return {Function}
 	 */
-	
-	function save (str, isString) {
-	  var i = saved.length
-	  saved[i] = isString
-	    ? str.replace(newlineRE, '\\n')
-	    : str
-	  return '"' + i + '"'
+
+	function compile (el, options, partial, transcluded) {
+	  // link function for the node itself.
+	  var nodeLinkFn = !partial
+	    ? compileRoot(el, options)
+	    : compileNode(el, options)
+	  // link function for the childNodes
+	  var childLinkFn =
+	    !(nodeLinkFn && nodeLinkFn.terminal) &&
+	    el.tagName !== 'SCRIPT' &&
+	    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
+	   * @return {Function|undefined}
+	   */
+
+	  function compositeLinkFn (vm, el) {
+	    // save original directive count before linking
+	    // so we can capture the directives created during a
+	    // partial compilation.
+	    var originalDirCount = vm._directives.length
+	    var parentOriginalDirCount =
+	      vm.$parent && vm.$parent._directives.length
+	    // cache childNodes before linking parent, fix #657
+	    var childNodes = _.toArray(el.childNodes)
+	    // if this is a transcluded compile, linkers need to be
+	    // called in source scope, and the host needs to be
+	    // passed down.
+	    var source = transcluded ? vm.$parent : vm
+	    var host = transcluded ? vm : undefined
+	    // link
+	    if (nodeLinkFn) nodeLinkFn(source, el, host)
+	    if (childLinkFn) childLinkFn(source, childNodes, host)
+
+	    var selfDirs = vm._directives.slice(originalDirCount)
+	    var parentDirs = vm.$parent &&
+	      vm.$parent._directives.slice(parentOriginalDirCount)
+
+	    /**
+	     * The linker function returns an unlink function that
+	     * tearsdown all directives instances generated during
+	     * the process.
+	     *
+	     * @param {Boolean} destroying
+	     */
+	    return function unlink (destroying) {
+	      teardownDirs(vm, selfDirs, destroying)
+	      if (parentDirs) {
+	        teardownDirs(vm.$parent, parentDirs)
+	      }
+	    }
+	  }
+
+	  // transcluded linkFns are terminal, because it takes
+	  // over the entire sub-tree.
+	  if (transcluded) {
+	    compositeLinkFn.terminal = true
+	  }
+
+	  return compositeLinkFn
 	}
-	
+
 	/**
-	 * Path rewrite replacer
+	 * Teardown a subset of directives on a vm.
 	 *
-	 * @param {String} raw
-	 * @return {String}
+	 * @param {Vue} vm
+	 * @param {Array} dirs
+	 * @param {Boolean} destroying
 	 */
-	
-	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
+
+	function teardownDirs (vm, dirs, destroying) {
+	  var i = dirs.length
+	  while (i--) {
+	    dirs[i]._teardown()
+	    if (!destroying) {
+	      vm._directives.$remove(dirs[i])
+	    }
 	  }
 	}
-	
+
 	/**
-	 * Restore replacer
+	 * Compile the root element of an instance. There are
+	 * 3 types of things to process here:
+	 * 
+	 * 1. props on parent container (child scope)
+	 * 2. other attrs on parent container (parent scope)
+	 * 3. attrs on the component template root node, if
+	 *    replace:true (child scope)
 	 *
-	 * @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.
+	 * Also, if this is a block instance, we only need to
+	 * compile 1 & 2 here.
 	 *
-	 * @param {String} exp
-	 * @param {Boolean} needSet
+	 * @param {Element} el
+	 * @param {Object} options
 	 * @return {Function}
 	 */
-	
-	function compileExpFns (exp, needSet) {
-	  if (improperKeywordsRE.test(exp)) {
-	    _.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 becaue the regex matches 1 extra char
-	  body = (' ' + body)
-	    .replace(pathReplaceRE, rewrite)
-	    .replace(restoreRE, restore)
-	  var getter = makeGetter(body)
-	  if (getter) {
-	    return {
-	      get: getter,
-	      body: body,
-	      set: needSet
-	        ? makeSetter(body)
-	        : null
+
+	function compileRoot (el, options) {
+	  var containerAttrs = options._containerAttrs
+	  var replacerAttrs = options._replacerAttrs
+	  var props = options.props
+	  var propsLinkFn, parentLinkFn, replacerLinkFn
+	  // 1. props
+	  propsLinkFn = props && containerAttrs
+	    ? compileProps(el, containerAttrs, props)
+	    : null
+	  // only need to compile other attributes for
+	  // non-block 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) {
+	        parentLinkFn = compileDirectives(containerAttrs, options)
+	      }
+	      if (replacerAttrs) {
+	        // 3. replacer attributes
+	        replacerLinkFn = compileDirectives(replacerAttrs, options)
+	      }
+	    } else {
+	      // non-component, just compile as a normal element.
+	      replacerLinkFn = compileDirectives(el, options)
 	    }
 	  }
+	  return function rootLinkFn (vm, el, host) {
+	    // explicitly passing null to props
+	    // linkers because they don't need a real element
+	    if (propsLinkFn) propsLinkFn(vm, null)
+	    if (parentLinkFn) parentLinkFn(vm.$parent, el, host)
+	    if (replacerLinkFn) replacerLinkFn(vm, el, host)
+	  }
 	}
-	
+
 	/**
-	 * Compile getter setters for a simple path.
+	 * Compile a node and return a nodeLinkFn based on the
+	 * node type.
 	 *
-	 * @param {String} exp
-	 * @return {Function}
+	 * @param {Node} node
+	 * @param {Object} options
+	 * @return {Function|null}
 	 */
-	
-	function compilePathFns (exp) {
-	  var getter, path
-	  if (exp.indexOf('[') < 0) {
-	    // really simple path
-	    path = exp.split('.')
-	    getter = Path.compileGetter(path)
+
+	function compileNode (node, options) {
+	  var type = node.nodeType
+	  if (type === 1 && node.tagName !== 'SCRIPT') {
+	    return compileElement(node, options)
+	  } else if (type === 3 && config.interpolate && node.data.trim()) {
+	    return compileTextNode(node, options)
 	  } else {
-	    // do the real parsing
-	    path = Path.parse(exp)
-	    getter = path.get
-	  }
-	  return {
-	    get: getter,
-	    // always generate setter for simple paths
-	    set: function (obj, val) {
-	      Path.set(obj, path, val)
-	    }
+	    return null
 	  }
 	}
-	
+
 	/**
-	 * 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.
+	 * Compile an element and return a nodeLinkFn.
 	 *
-	 * @param {String} body
-	 * @return {Function|undefined}
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Function|null}
 	 */
-	
-	function makeGetter (body) {
-	  try {
-	    return new Function('scope', 'return ' + body + ';')
-	  } catch (e) {
-	    _.warn(
-	      'Invalid expression. ' +
-	      'Generated function body: ' + body
-	    )
+
+	function compileElement (el, options) {
+	  var hasAttrs = el.hasAttributes()
+	  if (hasAttrs && checkTransclusion(el)) {
+	    // unwrap textNode
+	    if (el.hasAttribute('__vue__wrap')) {
+	      el = el.firstChild
+	    }
+	    return compile(el, options._parent.$options, true, true)
+	  }
+	  // check element directives
+	  var linkFn = checkElementDirectives(el, options)
+	  // check terminal direcitves (repeat & if)
+	  if (!linkFn && hasAttrs) {
+	    linkFn = checkTerminalDirectives(el, options)
+	  }
+	  // check component
+	  if (!linkFn) {
+	    linkFn = checkComponent(el, options)
+	  }
+	  // normal directives
+	  if (!linkFn && hasAttrs) {
+	    linkFn = compileDirectives(el, options)
+	  }
+	  // if the element is a textarea, we need to interpolate
+	  // its content on initial render.
+	  if (el.tagName === 'TEXTAREA') {
+	    var realLinkFn = linkFn
+	    linkFn = function (vm, el) {
+	      el.value = vm.$interpolate(el.value)
+	      if (realLinkFn) realLinkFn(vm, el)
+	    }
+	    linkFn.terminal = true
 	  }
+	  return linkFn
 	}
-	
+
 	/**
-	 * Build a setter function.
-	 *
-	 * This is only needed in rare situations like "a[b]" where
-	 * a settable path requires dynamic evaluation.
-	 *
-	 * This setter function may throw error when called if the
-	 * expression body is not a valid left-hand expression in
-	 * assignment.
+	 * Compile a textNode and return a nodeLinkFn.
 	 *
-	 * @param {String} body
-	 * @return {Function|undefined}
+	 * @param {TextNode} node
+	 * @param {Object} options
+	 * @return {Function|null} textNodeLinkFn
 	 */
-	
-	function makeSetter (body) {
-	  try {
-	    return new Function('scope', 'value', body + '=value;')
-	  } catch (e) {
-	    _.warn('Invalid setter function body: ' + body)
+
+	function compileTextNode (node, options) {
+	  var tokens = textParser.parse(node.data)
+	  if (!tokens) {
+	    return null
 	  }
+	  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)
 	}
-	
+
 	/**
-	 * Check for setter existence on a cache hit.
+	 * Process a single text token.
 	 *
-	 * @param {Function} hit
+	 * @param {Object} token
+	 * @param {Object} options
+	 * @return {Node}
 	 */
-	
-	function checkSetter (hit) {
-	  if (!hit.set) {
-	    hit.set = makeSetter(hit.body)
+
+	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) {
+	    token.type = type
+	    token.def = resolveAsset(options, 'directives', type)
+	    token.descriptor = dirParser.parse(token.value)[0]
 	  }
+	  return el
 	}
-	
+
 	/**
-	 * Parse an expression into re-written getter/setters.
+	 * Build a function that processes a textNode.
 	 *
-	 * @param {String} exp
-	 * @param {Boolean} needSet
-	 * @return {Function}
+	 * @param {Array<Object>} tokens
+	 * @param {DocumentFragment} frag
 	 */
-	
-	exports.parse = function (exp, needSet) {
-	  exp = exp.trim()
-	  // try cache
-	  var hit = expressionCache.get(exp)
-	  if (hit) {
-	    if (needSet) {
-	      checkSetter(hit)
+
+	function makeTextNodeLinkFn (tokens, frag) {
+	  return function textNodeLinkFn (vm, el) {
+	    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 = vm.$eval(value)
+	          if (token.html) {
+	            _.replace(node, templateParser.parse(value, true))
+	          } else {
+	            node.data = value
+	          }
+	        } else {
+	          vm._bindDir(token.type, node,
+	                      token.descriptor, token.def)
+	        }
+	      }
 	    }
-	    return hit
+	    _.replace(el, fragClone)
 	  }
-	  // we do a simple path check to optimize for them.
-	  // the check fails valid paths with unusal whitespaces,
-	  // but that's too rare and we don't care.
-	  // also skip boolean literals and paths that start with
-	  // global "Math"
-	  var res =
-	    pathTestRE.test(exp) &&
-	    // don't treat true/false as paths
-	    !booleanLiteralRE.test(exp) &&
-	    // Math constants e.g. Math.PI, Math.E etc.
-	    exp.slice(0, 5) !== 'Math.'
-	      ? compilePathFns(exp)
-	      : compileExpFns(exp, needSet)
-	  expressionCache.put(exp, res)
-	  return res
 	}
-	
-	// Export the pathRegex for external use
-	exports.pathTestRE = pathTestRE
-
-/***/ },
-/* 23 */
-/***/ function(module, exports, __webpack_require__) {
 
-	var uid = 0
-	var _ = __webpack_require__(11)
-	
 	/**
-	 * A dep is an observable that can have multiple
-	 * directives subscribing to it.
+	 * Compile a node list and return a childLinkFn.
 	 *
-	 * @constructor
+	 * @param {NodeList} nodeList
+	 * @param {Object} options
+	 * @return {Function|undefined}
 	 */
-	
-	function Dep () {
-	  this.id = ++uid
-	  this.subs = []
+
+	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
 	}
-	
-	var p = Dep.prototype
-	
+
 	/**
-	 * Add a directive subscriber.
+	 * Make a child link function for a node's childNodes.
 	 *
-	 * @param {Directive} sub
+	 * @param {Array<Function>} linkFns
+	 * @return {Function} childLinkFn
 	 */
-	
-	p.addSub = function (sub) {
-	  this.subs.push(sub)
+
+	function makeChildLinkFn (linkFns) {
+	  return function childLinkFn (vm, nodes, host) {
+	    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)
+	      }
+	      if (childrenLinkFn) {
+	        childrenLinkFn(vm, childNodes, host)
+	      }
+	    }
+	  }
 	}
-	
+
 	/**
-	 * Remove a directive subscriber.
+	 * Compile param attributes on a root element and return
+	 * a props link function.
 	 *
-	 * @param {Directive} sub
+	 * @param {Element|DocumentFragment} el
+	 * @param {Object} attrs
+	 * @param {Array} propNames
+	 * @return {Function} propsLinkFn
 	 */
-	
-	p.removeSub = function (sub) {
-	  this.subs.$remove(sub)
+
+	// regex to test if a path is "settable"
+	// if not the prop binding is automatically one-way.
+	var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]\])*$/
+
+	function compileProps (el, attrs, propNames) {
+	  var props = []
+	  var i = propNames.length
+	  var name, value, prop
+	  while (i--) {
+	    name = propNames[i]
+	    if (/[A-Z]/.test(name)) {
+	      _.warn(
+	        'You seem to be using camelCase for a component prop, ' +
+	        'but HTML doesn\'t differentiate between upper and ' +
+	        'lower case. You should use hyphen-delimited ' +
+	        'attribute names. For more info see ' +
+	        'http://vuejs.org/api/options.html#props'
+	      )
+	    }
+	    value = attrs[name]
+	    /* jshint eqeqeq:false */
+	    if (value != null) {
+	      prop = {
+	        name: name,
+	        raw: value
+	      }
+	      var tokens = textParser.parse(value)
+	      if (tokens) {
+	        if (el && el.nodeType === 1) {
+	          el.removeAttribute(name)
+	        }
+	        attrs[name] = null
+	        prop.dynamic = true
+	        prop.value = textParser.tokensToExp(tokens)
+	        prop.oneTime =
+	          tokens.length > 1 ||
+	          tokens[0].oneTime ||
+	          !settablePathRE.test(prop.value)
+	      }
+	      props.push(prop)
+	    }
+	  }
+	  return makePropsLinkFn(props)
 	}
-	
+
 	/**
-	 * Notify all subscribers of a new value.
+	 * Build a function that applies props to a vm.
+	 *
+	 * @param {Array} props
+	 * @return {Function} propsLinkFn
 	 */
-	
-	p.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 dataAttrRE = /^data-/
+
+	function makePropsLinkFn (props) {
+	  return function propsLinkFn (vm, el) {
+	    var i = props.length
+	    var prop, path
+	    while (i--) {
+	      prop = props[i]
+	      // props could contain dashes, which will be
+	      // interpreted as minus calculations by the parser
+	      // so we need to wrap the path here
+	      path = _.camelize(prop.name.replace(dataAttrRE, ''))
+	      if (prop.dynamic) {
+	        if (vm.$parent) {
+	          vm._bindDir('prop', el, {
+	            arg: path,
+	            expression: prop.value,
+	            oneWay: prop.oneTime
+	          }, propDef)
+	        } else {
+	          _.warn(
+	            'Cannot bind dynamic prop on a root instance' +
+	            ' with no parent: ' + prop.name + '="' +
+	            prop.raw + '"'
+	          )
+	        }
+	      } else {
+	        // just set once
+	        vm.$set(path, prop.raw)
+	      }
+	    }
 	  }
 	}
-	
-	module.exports = Dep
 
-/***/ },
-/* 24 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var config = __webpack_require__(15)
-	var Watcher = __webpack_require__(25)
-	var textParser = __webpack_require__(19)
-	var expParser = __webpack_require__(22)
-	
-	/**
-	 * 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 {String} name
-	 * @param {Node} el
-	 * @param {Vue} vm
-	 * @param {Object} descriptor
-	 *                 - {String} expression
-	 *                 - {String} [arg]
-	 *                 - {Array<Object>} [filters]
-	 * @param {Object} def - directive definition object
-	 * @param {Vue|undefined} host - transclusion host target
-	 * @constructor
-	 */
-	
-	function Directive (name, el, vm, descriptor, def, host) {
-	  // public
-	  this.name = name
-	  this.el = el
-	  this.vm = vm
-	  // copy descriptor props
-	  this.raw = descriptor.raw
-	  this.expression = descriptor.expression
-	  this.arg = descriptor.arg
-	  this.filters = _.resolveFilters(vm, descriptor.filters)
-	  // private
-	  this._host = host
-	  this._locked = false
-	  this._bound = false
-	  // init
-	  this._bind(def)
-	}
-	
-	var p = Directive.prototype
-	
 	/**
-	 * Initialize the directive, mixin definition properties,
-	 * setup the watcher, call definition bind() and update()
-	 * if present.
+	 * Check for element directives (custom elements that should
+	 * be resovled as terminal directives).
 	 *
-	 * @param {Object} def
+	 * @param {Element} el
+	 * @param {Object} options
 	 */
-	
-	p._bind = function (def) {
-	  if (this.name !== 'cloak' && this.el && this.el.removeAttribute) {
-	    this.el.removeAttribute(config.prefix + this.name)
-	  }
-	  if (typeof def === 'function') {
-	    this.update = def
-	  } else {
-	    _.extend(this, def)
-	  }
-	  this._watcherExp = this.expression
-	  this._checkDynamicLiteral()
-	  if (this.bind) {
-	    this.bind()
-	  }
-	  if (this._watcherExp &&
-	      (this.update || this.twoWay) &&
-	      (!this.isLiteral || this._isDynamicLiteral) &&
-	      !this._checkStatement()) {
-	    // wrapped updater for context
-	    var dir = this
-	    var update = this._update = this.update
-	      ? function (val, oldVal) {
-	          if (!dir._locked) {
-	            dir.update(val, oldVal)
-	          }
-	        }
-	      : function () {} // noop if no update is provided
-	    // use raw expression as identifier because filters
-	    // make them different watchers
-	    var watcher = this.vm._watchers[this.raw]
-	    // v-repeat always creates a new watcher because it has
-	    // a special filter that's bound to its directive
-	    // instance.
-	    if (!watcher || this.name === 'repeat') {
-	      watcher = this.vm._watchers[this.raw] = new Watcher(
-	        this.vm,
-	        this._watcherExp,
-	        update, // callback
-	        {
-	          filters: this.filters,
-	          twoWay: this.twoWay,
-	          deep: this.deep
-	        }
-	      )
-	    } else {
-	      watcher.addCb(update)
-	    }
-	    this._watcher = watcher
-	    if (this._initValue != null) {
-	      watcher.set(this._initValue)
-	    } else if (this.update) {
-	      this.update(watcher.value)
-	    }
+
+	function checkElementDirectives (el, options) {
+	  var tag = el.tagName.toLowerCase()
+	  var def = resolveAsset(options, 'elementDirectives', tag)
+	  if (def) {
+	    return makeTerminalNodeLinkFn(el, tag, '', options, def)
 	  }
-	  this._bound = true
 	}
-	
+
 	/**
-	 * check if this is a dynamic literal binding.
+	 * Check if an element is a component. If yes, return
+	 * a component link function.
 	 *
-	 * e.g. v-component="{{currentView}}"
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Function|undefined}
 	 */
-	
-	p._checkDynamicLiteral = function () {
-	  var expression = this.expression
-	  if (expression && this.isLiteral) {
-	    var tokens = textParser.parse(expression)
-	    if (tokens) {
-	      var exp = textParser.tokensToExp(tokens)
-	      this.expression = this.vm.$get(exp)
-	      this._watcherExp = exp
-	      this._isDynamicLiteral = true
+
+	function checkComponent (el, options) {
+	  var componentId = _.checkComponent(el, options)
+	  if (componentId) {
+	    var componentLinkFn = function (vm, el, host) {
+	      vm._bindDir('component', el, {
+	        expression: componentId
+	      }, componentDef, host)
 	    }
+	    componentLinkFn.terminal = true
+	    return componentLinkFn
 	  }
 	}
-	
+
 	/**
-	 * 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. v-on="click: a++"
+	 * Check an element for terminal directives in fixed order.
+	 * If it finds one, return a terminal link function.
 	 *
-	 * @return {Boolean}
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Function} terminalLinkFn
 	 */
-	
-	p._checkStatement = function () {
-	  var expression = this.expression
-	  if (
-	    expression && this.acceptStatement &&
-	    !expParser.pathTestRE.test(expression)
-	  ) {
-	    var fn = expParser.parse(expression).get
-	    var vm = this.vm
-	    var handler = function () {
-	      fn.call(vm, vm)
-	    }
-	    if (this.filters) {
-	      handler = _.applyFilters(
-	        handler,
-	        this.filters.read,
-	        vm
-	      )
+
+	function checkTerminalDirectives (el, options) {
+	  if (_.attr(el, 'pre') !== null) {
+	    return skip
+	  }
+	  var value, dirName
+	  /* jshint boss: true */
+	  for (var i = 0, l = terminalDirectives.length; i < l; i++) {
+	    dirName = terminalDirectives[i]
+	    if ((value = _.attr(el, dirName)) !== null) {
+	      return makeTerminalNodeLinkFn(el, dirName, value, options)
 	    }
-	    this.update(handler)
-	    return true
 	  }
 	}
-	
+
+	function skip () {}
+	skip.terminal = true
+
 	/**
-	 * Check for an attribute directive param, e.g. lazy
+	 * 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 {String} name
-	 * @return {String}
+	 * @param {Element} el
+	 * @param {String} dirName
+	 * @param {String} value
+	 * @param {Object} options
+	 * @param {Object} [def]
+	 * @return {Function} terminalLinkFn
 	 */
-	
-	p._checkParam = function (name) {
-	  var param = this.el.getAttribute(name)
-	  if (param !== null) {
-	    this.el.removeAttribute(name)
+
+	function makeTerminalNodeLinkFn (el, dirName, value, options, def) {
+	  var descriptor = dirParser.parse(value)[0]
+	  // no need to call resolveAsset since terminal directives
+	  // are always internal
+	  def = def || options.directives[dirName]
+	  var fn = function terminalNodeLinkFn (vm, el, host) {
+	    vm._bindDir(dirName, el, descriptor, def, host)
 	  }
-	  return param
+	  fn.terminal = true
+	  return fn
 	}
-	
+
 	/**
-	 * Teardown the watcher and call unbind.
+	 * Compile the directives on an element and return a linker.
+	 *
+	 * @param {Element|Object} elOrAttrs
+	 *        - could be an object of already-extracted
+	 *          container attributes.
+	 * @param {Object} options
+	 * @return {Function}
 	 */
-	
-	p._teardown = function () {
-	  if (this._bound) {
-	    if (this.unbind) {
-	      this.unbind()
-	    }
-	    var watcher = this._watcher
-	    if (watcher && watcher.active) {
-	      watcher.removeCb(this._update)
-	      if (!watcher.active) {
-	        this.vm._watchers[this.raw] = null
+
+	function compileDirectives (elOrAttrs, options) {
+	  var attrs = _.isPlainObject(elOrAttrs)
+	    ? mapToList(elOrAttrs)
+	    : elOrAttrs.attributes
+	  var i = attrs.length
+	  var dirs = []
+	  var attr, name, value, dir, dirName, dirDef
+	  while (i--) {
+	    attr = attrs[i]
+	    name = attr.name
+	    value = attr.value
+	    if (value === null) continue
+	    if (name.indexOf(config.prefix) === 0) {
+	      dirName = name.slice(config.prefix.length)
+	      dirDef = resolveAsset(options, 'directives', dirName)
+	      _.assertAsset(dirDef, 'directive', dirName)
+	      if (dirDef) {
+	        dirs.push({
+	          name: dirName,
+	          descriptors: dirParser.parse(value),
+	          def: dirDef
+	        })
+	      }
+	    } else if (config.interpolate) {
+	      dir = collectAttrDirective(name, value, options)
+	      if (dir) {
+	        dirs.push(dir)
 	      }
 	    }
-	    this._bound = false
-	    this.vm = this.el = this._watcher = null
+	  }
+	  // sort by priority, LOW to HIGH
+	  if (dirs.length) {
+	    dirs.sort(directiveComparator)
+	    return makeNodeLinkFn(dirs)
 	  }
 	}
-	
+
 	/**
-	 * Set the corresponding value with the setter.
-	 * This should only be used in two-way directives
-	 * e.g. v-model.
+	 * Convert a map (Object) of attributes to an Array.
 	 *
-	 * @param {*} value
-	 * @param {Boolean} lock - prevent wrtie triggering update.
-	 * @public
+	 * @param {Object} map
+	 * @return {Array}
 	 */
-	
-	p.set = function (value, lock) {
-	  if (this.twoWay) {
-	    if (lock) {
-	      this._locked = true
-	    }
-	    this._watcher.set(value)
-	    if (lock) {
-	      var self = this
-	      _.nextTick(function () {
-	        self._locked = false
-	      })
-	    }
+
+	function mapToList (map) {
+	  var list = []
+	  for (var key in map) {
+	    list.push({
+	      name: key,
+	      value: map[key]
+	    })
 	  }
+	  return list
 	}
-	
-	module.exports = Directive
-
-/***/ },
-/* 25 */
-/***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var config = __webpack_require__(15)
-	var Observer = __webpack_require__(26)
-	var expParser = __webpack_require__(22)
-	var batcher = __webpack_require__(55)
-	var uid = 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.
+	 * Build a link function for all directives on a single node.
 	 *
-	 * @param {Vue} vm
-	 * @param {String} expression
-	 * @param {Function} cb
-	 * @param {Object} options
-	 *                 - {Array} filters
-	 *                 - {Boolean} twoWay
-	 *                 - {Boolean} deep
-	 *                 - {Boolean} user
-	 * @constructor
+	 * @param {Array} directives
+	 * @return {Function} directivesLinkFn
 	 */
-	
-	function Watcher (vm, expression, cb, options) {
-	  this.vm = vm
-	  vm._watcherList.push(this)
-	  this.expression = expression
-	  this.cbs = [cb]
-	  this.id = ++uid // uid for batching
-	  this.active = true
-	  options = options || {}
-	  this.deep = !!options.deep
-	  this.user = !!options.user
-	  this.deps = Object.create(null)
-	  // setup filters if any.
-	  // We delegate directive filters here to the watcher
-	  // because they need to be included in the dependency
-	  // collection process.
-	  if (options.filters) {
-	    this.readFilters = options.filters.read
-	    this.writeFilters = options.filters.write
+
+	function makeNodeLinkFn (directives) {
+	  return function nodeLinkFn (vm, el, host) {
+	    // reverse apply because it's sorted low to high
+	    var i = directives.length
+	    var dir, j, k
+	    while (i--) {
+	      dir = directives[i]
+	      if (dir._link) {
+	        // custom link fn
+	        dir._link(vm, el)
+	      } else {
+	        k = dir.descriptors.length
+	        for (j = 0; j < k; j++) {
+	          vm._bindDir(dir.name, el,
+	            dir.descriptors[j], dir.def, host)
+	        }
+	      }
+	    }
 	  }
-	  // parse expression for getter/setter
-	  var res = expParser.parse(expression, options.twoWay)
-	  this.getter = res.get
-	  this.setter = res.set
-	  this.value = this.get()
 	}
-	
-	var p = Watcher.prototype
-	
+
 	/**
-	 * Add a dependency to this directive.
+	 * Check an attribute for potential dynamic bindings,
+	 * and return a directive object.
 	 *
-	 * @param {Dep} dep
+	 * @param {String} name
+	 * @param {String} value
+	 * @param {Object} options
+	 * @return {Object}
 	 */
-	
-	p.addDep = function (dep) {
-	  var id = dep.id
-	  if (!this.newDeps[id]) {
-	    this.newDeps[id] = dep
-	    if (!this.deps[id]) {
-	      this.deps[id] = dep
-	      dep.addSub(this)
+
+	function collectAttrDirective (name, value, options) {
+	  var tokens = textParser.parse(value)
+	  if (tokens) {
+	    var def = options.directives.attr
+	    var i = tokens.length
+	    var allOneTime = true
+	    while (i--) {
+	      var token = tokens[i]
+	      if (token.tag && !token.oneTime) {
+	        allOneTime = false
+	      }
+	    }
+	    return {
+	      def: def,
+	      _link: allOneTime
+	        ? function (vm, el) {
+	            el.setAttribute(name, vm.$interpolate(value))
+	          }
+	        : function (vm, el) {
+	            var value = textParser.tokensToExp(tokens, vm)
+	            var desc = dirParser.parse(name + ':' + value)[0]
+	            vm._bindDir('attr', el, desc, def)
+	          }
 	    }
 	  }
 	}
-	
+
 	/**
-	 * Evaluate the getter, and re-collect dependencies.
+	 * Directive priority sort comparator
+	 *
+	 * @param {Object} a
+	 * @param {Object} b
 	 */
-	
-	p.get = function () {
-	  this.beforeGet()
-	  var vm = this.vm
-	  var value
-	  try {
-	    value = this.getter.call(vm, vm)
-	  } catch (e) {
-	    if (config.warnExpressionErrors) {
-	      _.warn(
-	        'Error when evaluating expression "' +
-	        this.expression + '":\n   ' + e
-	      )
-	    }
-	  }
-	  // "touch" every property so they are all tracked as
-	  // dependencies for deep watching
-	  if (this.deep) {
-	    traverse(value)
-	  }
-	  value = _.applyFilters(value, this.readFilters, vm)
-	  this.afterGet()
-	  return value
+
+	function directiveComparator (a, b) {
+	  a = a.def.priority || 0
+	  b = b.def.priority || 0
+	  return a > b ? 1 : -1
 	}
-	
+
 	/**
-	 * Set the corresponding value with the setter.
+	 * Check whether an element is transcluded
 	 *
-	 * @param {*} value
+	 * @param {Element} el
+	 * @return {Boolean}
 	 */
-	
-	p.set = function (value) {
-	  var vm = this.vm
-	  value = _.applyFilters(
-	    value, this.writeFilters, vm, this.value
-	  )
-	  try {
-	    this.setter.call(vm, vm, value)
-	  } catch (e) {
-	    if (config.warnExpressionErrors) {
-	      _.warn(
-	        'Error when evaluating setter "' +
-	        this.expression + '":\n   ' + e
-	      )
-	    }
+
+	var transcludedFlagAttr = '__vue__transcluded'
+	function checkTransclusion (el) {
+	  if (el.nodeType === 1 && el.hasAttribute(transcludedFlagAttr)) {
+	    el.removeAttribute(transcludedFlagAttr)
+	    return true
 	  }
 	}
-	
-	/**
-	 * Prepare for dependency collection.
-	 */
-	
-	p.beforeGet = function () {
-	  Observer.target = this
-	  this.newDeps = {}
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var Cache = __webpack_require__(18)
+	var templateCache = new Cache(1000)
+	var idSelectorCache = new Cache(1000)
+
+	var map = {
+	  _default : [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>'
+	]
+
+	var tagRE = /<([\w:]+)/
+	var entityRE = /&\w+;/
+
 	/**
-	 * Clean up for dependency collection.
+	 * Convert a string template to a DocumentFragment.
+	 * Determines correct wrapping by tag types. Wrapping
+	 * strategy found in jQuery & component/domify.
+	 *
+	 * @param {String} templateString
+	 * @return {DocumentFragment}
 	 */
-	
-	p.afterGet = function () {
-	  Observer.target = null
-	  for (var id in this.deps) {
-	    if (!this.newDeps[id]) {
-	      this.deps[id].removeSub(this)
-	    }
+
+	function stringToFragment (templateString) {
+	  // try a cache hit first
+	  var hit = templateCache.get(templateString)
+	  if (hit) {
+	    return hit
 	  }
-	  this.deps = this.newDeps
-	}
-	
-	/**
-	 * Subscriber interface.
-	 * Will be called when a dependency changes.
-	 */
-	
-	p.update = function () {
-	  if (!config.async || config.debug) {
-	    this.run()
+
+	  var frag = document.createDocumentFragment()
+	  var tagMatch = templateString.match(tagRE)
+	  var entityMatch = entityRE.test(templateString)
+
+	  if (!tagMatch && !entityMatch) {
+	    // text only, return a single text node.
+	    frag.appendChild(
+	      document.createTextNode(templateString)
+	    )
 	  } else {
-	    batcher.push(this)
+
+	    var tag    = tagMatch && tagMatch[1]
+	    var wrap   = map[tag] || map._default
+	    var depth  = wrap[0]
+	    var prefix = wrap[1]
+	    var suffix = wrap[2]
+	    var node   = document.createElement('div')
+
+	    node.innerHTML = prefix + templateString.trim() + suffix
+	    while (depth--) {
+	      node = node.lastChild
+	    }
+
+	    var child
+	    /* jshint boss:true */
+	    while (child = node.firstChild) {
+	      frag.appendChild(child)
+	    }
 	  }
+
+	  templateCache.put(templateString, frag)
+	  return frag
 	}
-	
+
 	/**
-	 * Batcher job interface.
-	 * Will be called by the batcher.
+	 * Convert a template node to a DocumentFragment.
+	 *
+	 * @param {Node} node
+	 * @return {DocumentFragment}
 	 */
-	
-	p.run = function () {
-	  if (this.active) {
-	    var value = this.get()
-	    if (
-	      value !== this.value ||
-	      Array.isArray(value) ||
-	      this.deep
-	    ) {
-	      var oldValue = this.value
-	      this.value = value
-	      var cbs = this.cbs
-	      for (var i = 0, l = cbs.length; i < l; i++) {
-	        cbs[i](value, oldValue)
-	        // if a callback also removed other callbacks,
-	        // we need to adjust the loop accordingly.
-	        var removed = l - cbs.length
-	        if (removed) {
-	          i -= removed
-	          l -= removed
-	        }
-	      }
-	    }
+
+	function nodeToFragment (node) {
+	  var tag = node.tagName
+	  // if its a template tag and the browser supports it,
+	  // its content is already a document fragment.
+	  if (
+	    tag === 'TEMPLATE' &&
+	    node.content instanceof DocumentFragment
+	  ) {
+	    return node.content
 	  }
-	}
-	
-	/**
-	 * Add a callback.
-	 *
-	 * @param {Function} cb
-	 */
-	
-	p.addCb = function (cb) {
-	  this.cbs.push(cb)
-	}
-	
-	/**
-	 * Remove a callback.
-	 *
-	 * @param {Function} cb
-	 */
-	
-	p.removeCb = function (cb) {
-	  var cbs = this.cbs
-	  if (cbs.length > 1) {
-	    cbs.$remove(cb)
-	  } else if (cb === cbs[0]) {
-	    this.teardown()
+	  // script template
+	  if (tag === 'SCRIPT') {
+	    return stringToFragment(node.textContent)
+	  }
+	  // normal node, clone it to avoid mutating the original
+	  var clone = exports.clone(node)
+	  var frag = document.createDocumentFragment()
+	  var child
+	  /* jshint boss:true */
+	  while (child = clone.firstChild) {
+	    frag.appendChild(child)
 	  }
+	  return frag
 	}
-	
+
+	// Test for the presence of the Safari template cloning bug
+	// https://bugs.webkit.org/show_bug.cgi?id=137755
+	var hasBrokenTemplate = _.inBrowser
+	  ? (function () {
+	      var a = document.createElement('div')
+	      a.innerHTML = '<template>1</template>'
+	      return !a.cloneNode(true).firstChild.innerHTML
+	    })()
+	  : false
+
+	// Test for IE10/11 textarea placeholder clone bug
+	var hasTextareaCloneBug = _.inBrowser
+	  ? (function () {
+	      var t = document.createElement('textarea')
+	      t.placeholder = 't'
+	      return t.cloneNode(true).value === 't'
+	    })()
+	  : false
+
 	/**
-	 * Remove self from all dependencies' subcriber list.
+	 * 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}
 	 */
-	
-	p.teardown = function () {
-	  if (this.active) {
-	    // remove self from vm's watcher list
-	    // we can skip this if the vm if being destroyed
-	    // which can improve teardown performance.
-	    if (!this.vm._isBeingDestroyed) {
-	      this.vm._watcherList.$remove(this)
+
+	exports.clone = function (node) {
+	  var res = node.cloneNode(true)
+	  var i, original, cloned
+	  /* istanbul ignore if */
+	  if (hasBrokenTemplate) {
+	    original = node.querySelectorAll('template')
+	    if (original.length) {
+	      cloned = res.querySelectorAll('template')
+	      i = cloned.length
+	      while (i--) {
+	        cloned[i].parentNode.replaceChild(
+	          original[i].cloneNode(true),
+	          cloned[i]
+	        )
+	      }
 	    }
-	    for (var id in this.deps) {
-	      this.deps[id].removeSub(this)
+	  }
+	  /* 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
+	        }
+	      }
 	    }
-	    this.active = false
-	    this.vm = this.cbs = this.value = null
 	  }
+	  return res
 	}
-	
-	
+
 	/**
-	 * Recrusively traverse an object to evoke all converted
-	 * getters, so that every nested property inside the object
-	 * is collected as a "deep" dependency.
+	 * Process the template option and normalizes it into a
+	 * a DocumentFragment that can be used as a partial or a
+	 * instance template.
 	 *
-	 * @param {Object} obj
+	 * @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} clone
+	 * @param {Boolean} noSelector
+	 * @return {DocumentFragment|undefined}
 	 */
-	
-	function traverse (obj) {
-	  var key, val, i
-	  for (key in obj) {
-	    val = obj[key]
-	    if (_.isArray(val)) {
-	      i = val.length
-	      while (i--) traverse(val[i])
-	    } else if (_.isObject(val)) {
-	      traverse(val)
+
+	exports.parse = function (template, clone, noSelector) {
+	  var node, frag
+
+	  // if the template is already a document fragment,
+	  // do nothing
+	  if (template instanceof DocumentFragment) {
+	    return clone
+	      ? template.cloneNode(true)
+	      : template
+	  }
+
+	  if (typeof template === 'string') {
+	    // id selector
+	    if (!noSelector && 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)
 	    }
+	  } else if (template.nodeType) {
+	    // a direct node
+	    frag = nodeToFragment(template)
 	  }
+
+	  return frag && clone
+	    ? exports.clone(frag)
+	    : frag
 	}
-	
-	module.exports = Watcher
 
 /***/ },
-/* 26 */
+/* 24 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var config = __webpack_require__(15)
-	var Dep = __webpack_require__(23)
-	var arrayMethods = __webpack_require__(53)
-	var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
-	__webpack_require__(54)
-	
-	var uid = 0
-	
-	/**
-	 * Type enums
-	 */
-	
-	var ARRAY  = 0
-	var OBJECT = 1
-	
-	/**
-	 * Augment an target Object or Array by intercepting
-	 * the prototype chain using __proto__
-	 *
-	 * @param {Object|Array} target
-	 * @param {Object} proto
-	 */
-	
-	function protoAugment (target, src) {
-	  target.__proto__ = src
-	}
-	
-	/**
-	 * Augment an target Object or Array by defining
-	 * hidden properties.
-	 *
-	 * @param {Object|Array} target
-	 * @param {Object} proto
-	 */
-	
-	function copyAugment (target, src, keys) {
-	  var i = keys.length
-	  var key
-	  while (i--) {
-	    key = keys[i]
-	    _.define(target, key, src[key])
+	var _ = __webpack_require__(2)
+	var Watcher = __webpack_require__(11)
+	var identRE = __webpack_require__(17).identRE
+
+	module.exports = {
+
+	  bind: function () {
+
+	    var child = this.vm
+	    var parent = child.$parent
+	    var childKey = this.arg
+	    var parentKey = this.expression
+
+	    if (!identRE.test(childKey)) {
+	      _.warn(
+	        'Invalid prop key: "' + childKey + '". Prop keys ' +
+	        'must be valid identifiers.'
+	      )
+	    }
+
+	    // simple lock to avoid circular updates.
+	    // without this it would stabilize too, but this makes
+	    // sure it doesn't cause other watchers to re-evaluate.
+	    var locked = false
+	    var lock = function () {
+	      locked = true
+	      _.nextTick(unlock)
+	    }
+	    var unlock = function () {
+	      locked = false
+	    }
+
+	    this.parentWatcher = new Watcher(
+	      parent,
+	      parentKey,
+	      function (val) {
+	        if (!locked) {
+	          lock()
+	          // all props have been initialized already
+	          child[childKey] = val
+	        }
+	      }
+	    )
+	    
+	    // set the child initial value first, before setting
+	    // up the child watcher to avoid triggering it
+	    // immediately.
+	    child.$set(childKey, this.parentWatcher.value)
+
+	    // only setup two-way binding if this is not a one-way
+	    // binding.
+	    if (!this._descriptor.oneWay) {
+	      this.childWatcher = new Watcher(
+	        child,
+	        childKey,
+	        function (val) {
+	          if (!locked) {
+	            lock()
+	            parent.$set(parentKey, val)
+	          }
+	        }
+	      )
+	    }
+	  },
+
+	  unbind: function () {
+	    if (this.parentWatcher) {
+	      this.parentWatcher.teardown()
+	    }
+	    if (this.childWatcher) {
+	      this.childWatcher.teardown()
+	    }
 	  }
+
 	}
-	
-	/**
-	 * 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
-	 * @param {Number} type
-	 * @constructor
-	 */
-	
-	function Observer (value, type) {
-	  this.id = ++uid
-	  this.value = value
-	  this.active = true
-	  this.deps = []
-	  _.define(value, '__ob__', this)
-	  if (type === ARRAY) {
-	    var augment = config.proto && _.hasProto
-	      ? protoAugment
-	      : copyAugment
-	    augment(value, arrayMethods, arrayKeys)
-	    this.observeArray(value)
-	  } else if (type === OBJECT) {
-	    this.walk(value)
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var templateParser = __webpack_require__(23)
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  /**
+	   * Setup. Two possible usages:
+	   *
+	   * - static:
+	   *   v-component="comp"
+	   *
+	   * - dynamic:
+	   *   v-component="{{currentView}}"
+	   */
+
+	  bind: function () {
+	    if (!this.el.__vue__) {
+	      // create a ref anchor
+	      this.anchor = _.createAnchor('v-component')
+	      _.replace(this.el, this.anchor)
+	      // check keep-alive options.
+	      // If yes, instead of destroying the active vm when
+	      // hiding (v-if) or switching (dynamic literal) it,
+	      // we simply remove it from the DOM and save it in a
+	      // cache object, with its constructor id as the key.
+	      this.keepAlive = this._checkParam('keep-alive') != null
+	      // check ref
+	      this.refID = _.attr(this.el, 'ref')
+	      if (this.keepAlive) {
+	        this.cache = {}
+	      }
+	      // check inline-template
+	      if (this._checkParam('inline-template') !== null) {
+	        // extract inline template as a DocumentFragment
+	        this.template = _.extractContent(this.el, true)
+	      }
+	      // component resolution related state
+	      this._pendingCb =
+	      this.ctorId =
+	      this.Ctor = null
+	      // if static, build right now.
+	      if (!this._isDynamicLiteral) {
+	        this.resolveCtor(this.expression, _.bind(function () {
+	          var child = this.build()
+	          child.$before(this.anchor)
+	          this.setCurrent(child)
+	        }, this))
+	      } else {
+	        // check dynamic component params
+	        this.readyEvent = this._checkParam('wait-for')
+	        this.transMode = this._checkParam('transition-mode')
+	      }
+	    } else {
+	      _.warn(
+	        'v-component="' + this.expression + '" cannot be ' +
+	        'used on an already mounted instance.'
+	      )
+	    }
+	  },
+
+	  /**
+	   * Public update, called by the watcher in the dynamic
+	   * literal scenario, e.g. v-component="{{view}}"
+	   */
+
+	  update: function (value) {
+	    this.realUpdate(value)
+	  },
+
+	  /**
+	   * Switch dynamic components. May resolve the component
+	   * asynchronously, and perform transition based on
+	   * specified transition mode. Accepts an async callback
+	   * which is called when the transition ends. (This is
+	   * exposed for vue-router)
+	   *
+	   * @param {String} value
+	   * @param {Function} [cb]
+	   */
+
+	  realUpdate: function (value, cb) {
+	    this.invalidatePending()
+	    if (!value) {
+	      // just remove current
+	      this.unbuild()
+	      this.remove(this.childVM, cb)
+	      this.unsetCurrent()
+	    } else {
+	      this.resolveCtor(value, _.bind(function () {
+	        this.unbuild()
+	        var newComponent = this.build()
+	        var self = this
+	        if (this.readyEvent) {
+	          newComponent.$once(this.readyEvent, function () {
+	            self.swapTo(newComponent, cb)
+	          })
+	        } else {
+	          this.swapTo(newComponent, cb)
+	        }
+	      }, this))
+	    }
+	  },
+
+	  /**
+	   * Resolve the component constructor to use when creating
+	   * the child vm.
+	   */
+
+	  resolveCtor: function (id, cb) {
+	    var self = this
+	    this._pendingCb = _.cancellable(function (ctor) {
+	      self.ctorId = id
+	      self.Ctor = ctor
+	      cb()
+	    })
+	    this.vm._resolveComponent(id, this._pendingCb)
+	  },
+
+	  /**
+	   * When the component changes or unbinds before an async
+	   * constructor is resolved, we need to invalidate its
+	   * pending callback.
+	   */
+
+	  invalidatePending: function () {
+	    if (this._pendingCb) {
+	      this._pendingCb.cancel()
+	      this._pendingCb = 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.
+	   *
+	   * @return {Vue} - the created instance
+	   */
+
+	  build: function () {
+	    if (this.keepAlive) {
+	      var cached = this.cache[this.ctorId]
+	      if (cached) {
+	        return cached
+	      }
+	    }
+	    var vm = this.vm
+	    var el = templateParser.clone(this.el)
+	    if (this.Ctor) {
+	      var child = vm.$addChild({
+	        el: el,
+	        template: this.template,
+	        _asComponent: true,
+	        _host: this._host
+	      }, this.Ctor)
+	      if (this.keepAlive) {
+	        this.cache[this.ctorId] = child
+	      }
+	      return child
+	    }
+	  },
+
+	  /**
+	   * Teardown the current child, but defers cleanup so
+	   * that we can separate the destroy and removal steps.
+	   */
+
+	  unbuild: function () {
+	    var child = this.childVM
+	    if (!child || this.keepAlive) {
+	      return
+	    }
+	    // the sole purpose of `deferCleanup` is so that we can
+	    // "deactivate" the vm right now and perform DOM removal
+	    // later.
+	    child.$destroy(false, true)
+	  },
+
+	  /**
+	   * Remove current destroyed child and manually do
+	   * the cleanup after removal.
+	   *
+	   * @param {Function} cb
+	   */
+
+	  remove: function (child, cb) {
+	    var keepAlive = this.keepAlive
+	    if (child) {
+	      child.$remove(function () {
+	        if (!keepAlive) child._cleanup()
+	        if (cb) cb()
+	      })
+	    } else if (cb) {
+	      cb()
+	    }
+	  },
+
+	  /**
+	   * Actually swap the components, depending on the
+	   * transition mode. Defaults to simultaneous.
+	   *
+	   * @param {Vue} target
+	   * @param {Function} [cb]
+	   */
+
+	  swapTo: function (target, cb) {
+	    var self = this
+	    var current = this.childVM
+	    this.unsetCurrent()
+	    this.setCurrent(target)
+	    switch (self.transMode) {
+	      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)
+	    }
+	  },
+
+	  /**
+	   * Set childVM and parent ref
+	   */
+	  
+	  setCurrent: function (child) {
+	    this.childVM = child
+	    var refID = child._refID || this.refID
+	    if (refID) {
+	      this.vm.$[refID] = child
+	    }
+	  },
+
+	  /**
+	   * Unset childVM and parent ref
+	   */
+
+	  unsetCurrent: function () {
+	    var child = this.childVM
+	    this.childVM = null
+	    var refID = (child && child._refID) || this.refID
+	    if (refID) {
+	      this.vm.$[refID] = null
+	    }
+	  },
+
+	  /**
+	   * Unbind.
+	   */
+
+	  unbind: function () {
+	    this.invalidatePending()
+	    this.unbuild()
+	    // destroy all keep-alive cached instances
+	    if (this.cache) {
+	      for (var key in this.cache) {
+	        this.cache[key].$destroy()
+	      }
+	      this.cache = null
+	    }
+	  }
+
+	}
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+	var templateParser = __webpack_require__(23)
+	var transcludedFlagAttr = '__vue__transcluded'
+
+	/**
+	 * 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-repeat.
+	 *
+	 * @param {Element} el
+	 * @param {Object} options
+	 * @return {Element|DocumentFragment}
+	 */
+
+	module.exports = 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)
+	  }
+	  // Mark content nodes and attrs so that the compiler
+	  // knows they should be compiled in parent scope.
+	  if (options && options._asComponent) {
+	    var i = el.childNodes.length
+	    while (i--) {
+	      var node = el.childNodes[i]
+	      if (node.nodeType === 1) {
+	        node.setAttribute(transcludedFlagAttr, '')
+	      } else if (node.nodeType === 3 && node.data.trim()) {
+	        // wrap transcluded textNodes in spans, because
+	        // raw textNodes can't be persisted through clones
+	        // by attaching attributes.
+	        var wrapper = document.createElement('span')
+	        wrapper.textContent = node.data
+	        wrapper.setAttribute('__vue__wrap', '')
+	        wrapper.setAttribute(transcludedFlagAttr, '')
+	        el.replaceChild(wrapper, node)
+	      }
+	    }
+	  }
+	  // for template tags, what we want is its content as
+	  // a documentFragment (for block instances)
+	  if (el.tagName === 'TEMPLATE') {
+	    el = templateParser.parse(el)
+	  }
+	  if (options && options.template) {
+	    el = transcludeTemplate(el, options)
+	  }
+	  if (el instanceof DocumentFragment) {
+	    // anchors for block 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 = templateParser.parse(template, true)
+	  if (!frag) {
+	    _.warn('Invalid template option: ' + template)
+	  } else {
+	    var rawContent = options._content || _.extractContent(el)
+	    var replacer = frag.firstChild
+	    if (options.replace) {
+	      if (
+	        frag.childNodes.length > 1 ||
+	        replacer.nodeType !== 1 ||
+	        // when root node has v-repeat, the instance ends up
+	        // having multiple top-level nodes, thus becoming a
+	        // block instance. (#835)
+	        replacer.hasAttribute(config.prefix + 'repeat')
+	      ) {
+	        transcludeContent(frag, rawContent)
+	        return frag
+	      } else {
+	        options._replacerAttrs = extractAttrs(replacer)
+	        mergeAttrs(el, replacer)
+	        transcludeContent(replacer, rawContent)
+	        return replacer
+	      }
+	    } else {
+	      el.appendChild(frag)
+	      transcludeContent(el, rawContent)
+	      return el
+	    }
 	  }
 	}
-	
-	Observer.target = null
-	
-	var p = Observer.prototype
-	
+
 	/**
-	 * 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.
+	 * Resolve <content> insertion points mimicking the behavior
+	 * of the Shadow DOM spec:
 	 *
-	 * @param {*} value
-	 * @return {Observer|undefined}
-	 * @static
+	 *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
+	 *
+	 * @param {Element|DocumentFragment} el
+	 * @param {Element} raw
 	 */
-	
-	Observer.create = function (value) {
-	  if (
-	    value &&
-	    value.hasOwnProperty('__ob__') &&
-	    value.__ob__ instanceof Observer
-	  ) {
-	    return value.__ob__
-	  } else if (_.isArray(value)) {
-	    return new Observer(value, ARRAY)
-	  } else if (
-	    _.isPlainObject(value) &&
-	    !value._isVue // avoid Vue instance
-	  ) {
-	    return new Observer(value, OBJECT)
+
+	function transcludeContent (el, raw) {
+	  var outlets = getOutlets(el)
+	  var i = outlets.length
+	  if (!i) return
+	  var outlet, select, selected, j, main
+
+	  function isDirectChild (node) {
+	    return node.parentNode === raw
+	  }
+
+	  // first pass, collect corresponding content
+	  // for each outlet.
+	  while (i--) {
+	    outlet = outlets[i]
+	    if (raw) {
+	      select = outlet.getAttribute('select')
+	      if (select) {  // select content
+	        selected = raw.querySelectorAll(select)
+	        if (selected.length) {
+	          // according to Shadow DOM spec, `select` can
+	          // only select direct children of the host node.
+	          // enforcing this also fixes #786.
+	          selected = [].filter.call(selected, isDirectChild)
+	        }
+	        outlet.content = selected.length
+	          ? selected
+	          : _.toArray(outlet.childNodes)
+	      } else { // default content
+	        main = outlet
+	      }
+	    } else { // fallback content
+	      outlet.content = _.toArray(outlet.childNodes)
+	    }
+	  }
+	  // second pass, actually insert the contents
+	  for (i = 0, j = outlets.length; i < j; i++) {
+	    outlet = outlets[i]
+	    if (outlet !== main) {
+	      insertContentAt(outlet, outlet.content)
+	    }
+	  }
+	  // finally insert the main content
+	  if (main) {
+	    insertContentAt(main, _.toArray(raw.childNodes))
 	  }
 	}
-	
+
 	/**
-	 * Walk through each property and convert them into
-	 * getter/setters. This method should only be called when
-	 * value type is Object. Properties prefixed with `$` or `_`
-	 * and accessor properties are ignored.
+	 * Get <content> outlets from the element/list
 	 *
-	 * @param {Object} obj
+	 * @param {Element|Array} el
+	 * @return {Array}
 	 */
-	
-	p.walk = function (obj) {
-	  var keys = Object.keys(obj)
-	  var i = keys.length
-	  var key, prefix
-	  while (i--) {
-	    key = keys[i]
-	    prefix = key.charCodeAt(0)
-	    if (prefix !== 0x24 && prefix !== 0x5F) { // skip $ or _
-	      this.convert(key, obj[key])
-	    }
+
+	var concat = [].concat
+	function getOutlets (el) {
+	  return _.isArray(el)
+	    ? concat.apply([], el.map(getOutlets))
+	    : el.querySelectorAll
+	      ? _.toArray(el.querySelectorAll('content'))
+	      : []
+	}
+
+	/**
+	 * Insert an array of nodes at outlet,
+	 * then remove the outlet.
+	 *
+	 * @param {Element} outlet
+	 * @param {Array} contents
+	 */
+
+	function insertContentAt (outlet, contents) {
+	  // not using util DOM methods here because
+	  // parentNode can be cached
+	  var parent = outlet.parentNode
+	  for (var i = 0, j = contents.length; i < j; i++) {
+	    parent.insertBefore(contents[i], outlet)
 	  }
+	  parent.removeChild(outlet)
 	}
-	
+
 	/**
-	 * Try to carete an observer for a child value,
-	 * and if value is array, link dep to the array.
+	 * Helper to extract a component container's attribute names
+	 * into a map. The resulting map will be used in compiler to
+	 * determine whether an attribute is transcluded.
 	 *
-	 * @param {*} val
-	 * @return {Dep|undefined}
+	 * @param {Element} el
+	 * @return {Object}
 	 */
-	
-	p.observe = function (val) {
-	  return Observer.create(val)
+
+	function extractAttrs (el) {
+	  if (el.nodeType === 1 && el.hasAttributes()) {
+	    var attrs = el.attributes
+	    var res = {}
+	    var i = attrs.length
+	    while (i--) {
+	      res[attrs[i].name] = attrs[i].value
+	    }
+	    return res
+	  }
 	}
-	
+
 	/**
-	 * Observe a list of Array items.
+	 * Merge the attributes of two elements, and make sure
+	 * the class names are merged properly.
 	 *
-	 * @param {Array} items
+	 * @param {Element} from
+	 * @param {Element} to
 	 */
-	
-	p.observeArray = function (items) {
-	  var i = items.length
+
+	function mergeAttrs (from, to) {
+	  var attrs = from.attributes
+	  var i = attrs.length
+	  var name, value
 	  while (i--) {
-	    this.observe(items[i])
+	    name = attrs[i].name
+	    value = attrs[i].value
+	    if (!to.hasAttribute(name)) {
+	      to.setAttribute(name, value)
+	    } else if (name === 'class') {
+	      to.className = to.className + ' ' + value
+	    }
 	  }
 	}
-	
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var config = __webpack_require__(4)
+
 	/**
-	 * Convert a property into getter/setter so we can emit
-	 * the events when the property is accessed/changed.
+	 * Expose useful internals
+	 */
+
+	exports.util = _
+	exports.nextTick = _.nextTick
+	exports.config = __webpack_require__(4)
+
+	exports.compiler = {
+	  compile: __webpack_require__(22),
+	  transclude: __webpack_require__(26)
+	}
+
+	exports.parsers = {
+	  path: __webpack_require__(17),
+	  text: __webpack_require__(20),
+	  template: __webpack_require__(23),
+	  directive: __webpack_require__(21),
+	  expression: __webpack_require__(16)
+	}
+
+	/**
+	 * Each instance constructor, including Vue, has a unique
+	 * cid. This enables us to create wrapped "child
+	 * constructors" for prototypal inheritance and cache them.
+	 */
+
+	exports.cid = 0
+	var cid = 1
+
+	/**
+	 * Class inehritance
 	 *
-	 * @param {String} key
-	 * @param {*} val
+	 * @param {Object} extendOptions
 	 */
-	
-	p.convert = function (key, val) {
-	  var ob = this
-	  var childOb = ob.observe(val)
-	  var dep = new Dep()
-	  if (childOb) {
-	    childOb.deps.push(dep)
-	  }
-	  Object.defineProperty(ob.value, key, {
-	    enumerable: true,
-	    configurable: true,
-	    get: function () {
-	      // Observer.target is a watcher whose getter is
-	      // currently being evaluated.
-	      if (ob.active && Observer.target) {
-	        Observer.target.addDep(dep)
-	      }
-	      return val
-	    },
-	    set: function (newVal) {
-	      if (newVal === val) return
-	      // remove dep from old value
-	      var oldChildOb = val && val.__ob__
-	      if (oldChildOb) {
-	        oldChildOb.deps.$remove(dep)
-	      }
-	      val = newVal
-	      // add dep to new value
-	      var newChildOb = ob.observe(newVal)
-	      if (newChildOb) {
-	        newChildOb.deps.push(dep)
-	      }
-	      dep.notify()
-	    }
-	  })
+
+	exports.extend = function (extendOptions) {
+	  extendOptions = extendOptions || {}
+	  var Super = this
+	  var Sub = createClass(
+	    extendOptions.name ||
+	    Super.options.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.
+	  createAssetRegisters(Sub)
+	  return Sub
 	}
-	
+
 	/**
-	 * Notify change on all self deps on an observer.
-	 * This is called when a mutable value mutates. e.g.
-	 * when an Array's mutating methods are called, or an
-	 * Object's $add/$delete are called.
+	 * 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}
 	 */
-	
-	p.notify = function () {
-	  var deps = this.deps
-	  for (var i = 0, l = deps.length; i < l; i++) {
-	    deps[i].notify()
-	  }
+
+	function createClass (name) {
+	  return new Function(
+	    'return function ' + _.classify(name) +
+	    ' (options) { this._init(options) }'
+	  )()
 	}
-	
+
 	/**
-	 * Add an owner vm, so that when $add/$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.
+	 * Plugin system
 	 *
-	 * @param {Vue} vm
+	 * @param {Object} plugin
 	 */
-	
-	p.addVm = function (vm) {
-	  (this.vms = this.vms || []).push(vm)
+
+	exports.use = function (plugin) {
+	  // 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)
+	  }
+	  return this
 	}
-	
+
 	/**
-	 * Remove an owner vm. This is called when the object is
-	 * swapped out as an instance's $data object.
+	 * Define asset registration methods on a constructor.
 	 *
-	 * @param {Vue} vm
+	 * @param {Function} Constructor
 	 */
-	
-	p.removeVm = function (vm) {
-	  this.vms.$remove(vm)
+
+	function createAssetRegisters (Constructor) {
+
+	  /* Asset registration methods share the same signature:
+	   *
+	   * @param {String} id
+	   * @param {*} definition
+	   */
+
+	  config._assetTypes.forEach(function (type) {
+	    Constructor[type] = function (id, definition) {
+	      if (!definition) {
+	        return this.options[type + 's'][id]
+	      } else {
+	        this.options[type + 's'][id] = definition
+	      }
+	    }
+	  })
+
+	  /**
+	   * Component registration needs to automatically invoke
+	   * Vue.extend on object values.
+	   *
+	   * @param {String} id
+	   * @param {Object|Function} definition
+	   */
+
+	  Constructor.component = function (id, definition) {
+	    if (!definition) {
+	      return this.options.components[id]
+	    } else {
+	      if (_.isPlainObject(definition)) {
+	        definition.name = id
+	        definition = _.Vue.extend(definition)
+	      }
+	      this.options.components[id] = definition
+	    }
+	  }
 	}
-	
-	module.exports = Observer
 
+	createAssetRegisters(exports)
 
 /***/ },
-/* 27 */
+/* 28 */
 /***/ function(module, exports, __webpack_require__) {
 
-	/**
-	 * Check is a string starts with $ or _
-	 *
-	 * @param {String} str
-	 * @return {Boolean}
-	 */
-	
-	exports.isReserved = function (str) {
-	  var c = (str + '').charCodeAt(0)
-	  return c === 0x24 || c === 0x5F
+	// manipulation directives
+	exports.text       = __webpack_require__(29)
+	exports.html       = __webpack_require__(30)
+	exports.attr       = __webpack_require__(31)
+	exports.show       = __webpack_require__(32)
+	exports['class']   = __webpack_require__(34)
+	exports.el         = __webpack_require__(35)
+	exports.ref        = __webpack_require__(36)
+	exports.cloak      = __webpack_require__(37)
+	exports.style      = __webpack_require__(38)
+	exports.transition = __webpack_require__(39)
+
+	// event listener directives
+	exports.on         = __webpack_require__(42)
+	exports.model      = __webpack_require__(43)
+
+	// logic control directives
+	exports.repeat     = __webpack_require__(48)
+	exports['if']      = __webpack_require__(49)
+
+	// child vm communication directives
+	exports.events     = __webpack_require__(50)
+
+	// internal directives that should not be used directly
+	// but we still want to expose them for advanced usage.
+	exports._component = __webpack_require__(25)
+	exports._prop      = __webpack_require__(24)
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
+	module.exports = {
+
+	  bind: function () {
+	    this.attr = this.el.nodeType === 3
+	      ? 'nodeValue'
+	      : 'textContent'
+	  },
+
+	  update: function (value) {
+	    this.el[this.attr] = _.toString(value)
+	  }
+	  
 	}
-	
-	/**
-	 * Guard text output, make sure undefined outputs
-	 * empty string
-	 *
-	 * @param {*} value
-	 * @return {String}
-	 */
-	
-	exports.toString = function (value) {
-	  return value == null
-	    ? ''
-	    : value.toString()
+
+/***/ },
+/* 30 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var templateParser = __webpack_require__(23)
+
+	module.exports = {
+
+	  bind: function () {
+	    // 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 (value) {
+	    value = _.toString(value)
+	    if (this.nodes) {
+	      this.swap(value)
+	    } else {
+	      this.el.innerHTML = value
+	    }
+	  },
+
+	  swap: function (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 = templateParser.parse(value, true, true)
+	    // save a reference to these nodes so we can remove later
+	    this.nodes = _.toArray(frag.childNodes)
+	    _.before(frag, this.anchor)
+	  }
+
 	}
-	
-	/**
-	 * Check and convert possible numeric numbers before
-	 * setting back to data
-	 *
-	 * @param {*} value
-	 * @return {*|Number}
-	 */
-	
-	exports.toNumber = function (value) {
-	  return (
-	    isNaN(value) ||
-	    value === null ||
-	    typeof value === 'boolean'
-	  ) ? value
-	    : Number(value)
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// xlink
+	var xlinkNS = 'http://www.w3.org/1999/xlink'
+	var xlinkRE = /^xlink:/
+
+	module.exports = {
+
+	  priority: 850,
+
+	  bind: function () {
+	    var name = this.arg
+	    this.update = xlinkRE.test(name)
+	      ? xlinkHandler
+	      : defaultHandler
+	  }
+
+	}
+
+	function defaultHandler (value) {
+	  if (value || value === 0) {
+	    this.el.setAttribute(this.arg, value)
+	  } else {
+	    this.el.removeAttribute(this.arg)
+	  }
+	}
+
+	function xlinkHandler (value) {
+	  if (value != null) {
+	    this.el.setAttributeNS(xlinkNS, this.arg, value)
+	  } else {
+	    this.el.removeAttributeNS(xlinkNS, 'href')
+	  }
+	}
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var transition = __webpack_require__(33)
+
+	module.exports = function (value) {
+	  var el = this.el
+	  transition.apply(el, value ? 1 : -1, function () {
+	    el.style.display = value ? '' : 'none'
+	  }, this.vm)
 	}
-	
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
 	/**
-	 * Strip quotes from a string
+	 * Append with transition.
 	 *
-	 * @param {String} str
-	 * @return {String | false}
+	 * @oaram {Element} el
+	 * @param {Element} target
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
 	 */
-	
-	exports.stripQuotes = function (str) {
-	  var a = str.charCodeAt(0)
-	  var b = str.charCodeAt(str.length - 1)
-	  return a === b && (a === 0x22 || a === 0x27)
-	    ? str.slice(1, -1)
-	    : false
+
+	exports.append = function (el, target, vm, cb) {
+	  apply(el, 1, function () {
+	    target.appendChild(el)
+	  }, vm, cb)
 	}
-	
+
 	/**
-	 * Replace helper
+	 * InsertBefore with transition.
 	 *
-	 * @param {String} _ - matched delimiter
-	 * @param {String} c - matched char
-	 * @return {String}
+	 * @oaram {Element} el
+	 * @param {Element} target
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
 	 */
-	function toUpper (_, c) {
-	  return c ? c.toUpperCase () : ''
+
+	exports.before = function (el, target, vm, cb) {
+	  apply(el, 1, function () {
+	    _.before(el, target)
+	  }, vm, cb)
 	}
-	
+
 	/**
-	 * Camelize a hyphen-delmited string.
+	 * Remove with transition.
 	 *
-	 * @param {String} str
-	 * @return {String}
+	 * @oaram {Element} el
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
 	 */
-	
-	var camelRE = /-(\w)/g
-	exports.camelize = function (str) {
-	  return str.replace(camelRE, toUpper)
+
+	exports.remove = function (el, vm, cb) {
+	  apply(el, -1, function () {
+	    _.remove(el)
+	  }, vm, cb)
 	}
-	
+
 	/**
-	 * Converts hyphen/underscore/slash delimitered names into
-	 * camelized classNames.
-	 *
-	 * e.g. my-component => MyComponent
-	 *      some_else    => SomeElse
-	 *      some/comp    => SomeComp
+	 * Remove by appending to another parent with transition.
+	 * This is only used in block operations.
 	 *
-	 * @param {String} str
-	 * @return {String}
+	 * @oaram {Element} el
+	 * @param {Element} target
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
 	 */
-	
-	var classifyRE = /(?:^|[-_\/])(\w)/g
-	exports.classify = function (str) {
-	  return str.replace(classifyRE, toUpper)
+
+	exports.removeThenAppend = function (el, target, vm, cb) {
+	  apply(el, -1, function () {
+	    target.appendChild(el)
+	  }, vm, cb)
 	}
-	
+
 	/**
-	 * Simple bind, faster than native
+	 * Append the childNodes of a fragment to target.
 	 *
-	 * @param {Function} fn
-	 * @param {Object} ctx
-	 * @return {Function}
+	 * @param {DocumentFragment} block
+	 * @param {Node} target
+	 * @param {Vue} vm
 	 */
-	
-	exports.bind = function (fn, ctx) {
-	  return function () {
-	    return fn.apply(ctx, arguments)
+
+	exports.blockAppend = function (block, target, vm) {
+	  var nodes = _.toArray(block.childNodes)
+	  for (var i = 0, l = nodes.length; i < l; i++) {
+	    exports.before(nodes[i], target, vm)
 	  }
 	}
-	
+
 	/**
-	 * Convert an Array-like object to a real Array.
+	 * Remove a block of nodes between two edge nodes.
 	 *
-	 * @param {Array-like} list
-	 * @param {Number} [start] - start index
-	 * @return {Array}
+	 * @param {Node} start
+	 * @param {Node} end
+	 * @param {Vue} vm
 	 */
-	
-	exports.toArray = function (list, start) {
-	  start = start || 0
-	  var i = list.length - start
-	  var ret = new Array(i)
-	  while (i--) {
-	    ret[i] = list[i + start]
+
+	exports.blockRemove = function (start, end, vm) {
+	  var node = start.nextSibling
+	  var next
+	  while (node !== end) {
+	    next = node.nextSibling
+	    exports.remove(node, vm)
+	    node = next
 	  }
-	  return ret
 	}
-	
+
 	/**
-	 * Mix properties into target object.
+	 * Apply transitions with an operation callback.
 	 *
-	 * @param {Object} to
-	 * @param {Object} from
+	 * @oaram {Element} el
+	 * @param {Number} direction
+	 *                  1: enter
+	 *                 -1: leave
+	 * @param {Function} op - the actual DOM operation
+	 * @param {Vue} vm
+	 * @param {Function} [cb]
 	 */
-	
-	exports.extend = function (to, from) {
-	  for (var key in from) {
-	    to[key] = from[key]
+
+	var apply = exports.apply = function (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)
+	}
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var addClass = _.addClass
+	var removeClass = _.removeClass
+
+	module.exports = function (value) {
+	  if (this.arg) {
+	    var method = value ? addClass : removeClass
+	    method(this.el, this.arg)
+	  } else {
+	    if (this.lastVal) {
+	      removeClass(this.el, this.lastVal)
+	    }
+	    if (value) {
+	      addClass(this.el, value)
+	      this.lastVal = value
+	    }
+	  }
+	}
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  bind: function () {
+	    this.vm.$$[this.expression] = this.el
+	  },
+
+	  unbind: function () {
+	    delete this.vm.$$[this.expression]
+	  }
+	  
+	}
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
+	module.exports = {
+
+	  isLiteral: true,
+
+	  bind: function () {
+	    var vm = this.el.__vue__
+	    if (!vm) {
+	      _.warn(
+	        'v-ref should only be used on a component root element.'
+	      )
+	      return
+	    }
+	    // If we get here, it means this is a `v-ref` on a
+	    // child, because parent scope `v-ref` is stripped in
+	    // `v-component` already. So we just record our own ref
+	    // here - it will overwrite parent ref in `v-component`,
+	    // if any.
+	    vm._refID = this.expression
+	  }
+	  
+	}
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var config = __webpack_require__(4)
+
+	module.exports = {
+
+	  bind: function () {
+	    var el = this.el
+	    this.vm.$once('hook:compiled', function () {
+	      el.removeAttribute(config.prefix + 'cloak')
+	    })
+	  }
+
+	}
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var prefixes = ['-webkit-', '-moz-', '-ms-']
+	var camelPrefixes = ['Webkit', 'Moz', 'ms']
+	var importantRE = /!important;?$/
+	var camelRE = /([a-z])([A-Z])/g
+	var testEl = null
+	var propCache = {}
+
+	module.exports = {
+
+	  deep: true,
+
+	  update: function (value) {
+	    if (this.arg) {
+	      this.setProp(this.arg, value)
+	    } else {
+	      if (typeof value === 'object') {
+	        // cache object styles so that only changed props
+	        // are actually updated.
+	        if (!this.cache) this.cache = {}
+	        for (var prop in value) {
+	          this.setProp(prop, value[prop])
+	          /* jshint eqeqeq: false */
+	          if (value[prop] != this.cache[prop]) {
+	            this.cache[prop] = value[prop]
+	            this.setProp(prop, value[prop])
+	          }
+	        }
+	      } else {
+	        this.el.style.cssText = value
+	      }
+	    }
+	  },
+
+	  setProp: function (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) {
+	        value = value.replace(importantRE, '').trim()
+	      }
+	      this.el.style.setProperty(prop, value, isImportant)
+	    } else {
+	      this.el.style.removeProperty(prop)
+	    }
 	  }
-	  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}
-	 */
-	
-	exports.isObject = function (obj) {
-	  return obj && typeof obj === 'object'
-	}
-	
-	/**
-	 * Strict object type check. Only returns true
-	 * for plain JavaScript objects.
-	 *
-	 * @param {*} obj
-	 * @return {Boolean}
-	 */
-	
-	var toString = Object.prototype.toString
-	exports.isPlainObject = function (obj) {
-	  return toString.call(obj) === '[object Object]'
-	}
-	
-	/**
-	 * Array type check.
-	 *
-	 * @param {*} obj
-	 * @return {Boolean}
-	 */
-	
-	exports.isArray = function (obj) {
-	  return Array.isArray(obj)
+
 	}
-	
+
 	/**
-	 * Define a non-enumerable property
+	 * Normalize a CSS property name.
+	 * - cache result
+	 * - auto prefix
+	 * - camelCase -> dash-case
 	 *
-	 * @param {Object} obj
-	 * @param {String} key
-	 * @param {*} val
-	 * @param {Boolean} [enumerable]
+	 * @param {String} prop
+	 * @return {String}
 	 */
-	
-	exports.define = function (obj, key, val, enumerable) {
-	  Object.defineProperty(obj, key, {
-	    value        : val,
-	    enumerable   : !!enumerable,
-	    writable     : true,
-	    configurable : true
-	  })
+
+	function normalize (prop) {
+	  if (propCache[prop]) {
+	    return propCache[prop]
+	  }
+	  var res = prefix(prop)
+	  propCache[prop] = propCache[res] = res
+	  return res
 	}
-	
+
 	/**
-	 * Debounce a function so it only gets called after the
-	 * input stops arriving after the given wait period.
+	 * Auto detect the appropriate prefix for a CSS property.
+	 * https://gist.github.com/paulirish/523692
 	 *
-	 * @param {Function} func
-	 * @param {Number} wait
-	 * @return {Function} - the debounced function
+	 * @param {String} prop
+	 * @return {String}
 	 */
-	
-	exports.debounce = function(func, wait) {
-	  var timeout, args, context, timestamp, result
-	  var later = function() {
-	    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
-	    }
+
+	function prefix (prop) {
+	  prop = prop.replace(camelRE, '$1-$2').toLowerCase()
+	  var camel = _.camelize(prop)
+	  var upper = camel.charAt(0).toUpperCase() + camel.slice(1)
+	  if (!testEl) {
+	    testEl = document.createElement('div')
 	  }
-	  return function() {
-	    context = this
-	    args = arguments
-	    timestamp = Date.now()
-	    if (!timeout) {
-	      timeout = setTimeout(later, wait)
+	  if (camel in testEl.style) {
+	    return prop
+	  }
+	  var i = prefixes.length
+	  var prefixed
+	  while (i--) {
+	    prefixed = camelPrefixes[i] + upper
+	    if (prefixed in testEl.style) {
+	      return prefixes[i] + prop
 	    }
-	    return result
 	  }
 	}
 
 /***/ },
-/* 28 */
+/* 39 */
 /***/ function(module, exports, __webpack_require__) {
 
-	/**
-	 * Can we use __proto__?
-	 *
-	 * @type {Boolean}
-	 */
-	
-	exports.hasProto = '__proto__' in {}
-	
-	/**
-	 * Indicates we have a window
-	 *
-	 * @type {Boolean}
-	 */
-	
-	var toString = Object.prototype.toString
-	var inBrowser = exports.inBrowser =
-	  typeof window !== 'undefined' &&
-	  toString.call(window) !== '[object Object]'
-	
-	/**
-	 * 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
-	 */
-	
-	exports.nextTick = (function () {
-	  var callbacks = []
-	  var pending = false
-	  var timerFunc
-	  function handle () {
-	    pending = false
-	    var copies = callbacks.slice(0)
-	    callbacks = []
-	    for (var i = 0; i < copies.length; i++) {
-	      copies[i]()
+	var _ = __webpack_require__(2)
+	var Transition = __webpack_require__(40)
+
+	module.exports = {
+
+	  priority: 1000,
+	  isLiteral: true,
+
+	  bind: function () {
+	    if (!this._isDynamicLiteral) {
+	      this.update(this.expression)
 	    }
-	  }
-	  /* istanbul ignore if */
-	  if (typeof MutationObserver !== 'undefined') {
-	    var counter = 1
-	    var observer = new MutationObserver(handle)
-	    var textNode = document.createTextNode(counter)
-	    observer.observe(textNode, {
-	      characterData: true
-	    })
-	    timerFunc = function () {
-	      counter = (counter + 1) % 2
-	      textNode.data = counter
+	  },
+
+	  update: function (id, oldId) {
+	    var el = this.el
+	    var vm = this.el.__vue__ || this.vm
+	    var hooks = _.resolveAsset(vm.$options, 'transitions', id)
+	    id = id || 'v'
+	    el.__v_trans = new Transition(el, id, hooks, vm)
+	    if (oldId) {
+	      _.removeClass(el, oldId + '-transition')
 	    }
-	  } else {
-	    timerFunc = setTimeout
-	  }
-	  return function (cb, ctx) {
-	    var func = ctx
-	      ? function () { cb.call(ctx) }
-	      : cb
-	    callbacks.push(func)
-	    if (pending) return
-	    pending = true
-	    timerFunc(handle, 0)
+	    _.addClass(el, id + '-transition')
 	  }
-	})()
-	
-	/**
-	 * Detect if we are in IE9...
-	 *
-	 * @type {Boolean}
-	 */
-	
-	exports.isIE9 =
-	  inBrowser &&
-	  navigator.userAgent.indexOf('MSIE 9.0') > 0
-	
-	/**
-	 * Sniff transition/animation events
-	 */
-	
-	if (inBrowser && !exports.isIE9) {
-	  var isWebkitTrans =
-	    window.ontransitionend === undefined &&
-	    window.onwebkittransitionend !== undefined
-	  var isWebkitAnim =
-	    window.onanimationend === undefined &&
-	    window.onwebkitanimationend !== undefined
-	  exports.transitionProp = isWebkitTrans
-	    ? 'WebkitTransition'
-	    : 'transition'
-	  exports.transitionEndEvent = isWebkitTrans
-	    ? 'webkitTransitionEnd'
-	    : 'transitionend'
-	  exports.animationProp = isWebkitAnim
-	    ? 'WebkitAnimation'
-	    : 'animation'
-	  exports.animationEndEvent = isWebkitAnim
-	    ? 'webkitAnimationEnd'
-	    : 'animationend'
+
 	}
 
 /***/ },
-/* 29 */
+/* 40 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var config = __webpack_require__(15)
-	
+	var _ = __webpack_require__(2)
+	var queue = __webpack_require__(41)
+	var addClass = _.addClass
+	var removeClass = _.removeClass
+	var transitionEndEvent = _.transitionEndEvent
+	var animationEndEvent = _.animationEndEvent
+	var transDurationProp = _.transitionProp + 'Duration'
+	var animDurationProp = _.animationProp + 'Duration'
+	var doc = typeof document === 'undefined' ? null : document
+
+	var TYPE_TRANSITION = 1
+	var TYPE_ANIMATION = 2
+
 	/**
-	 * 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 byy doing the
-	 * contains() check on the node's parentNode instead of
-	 * the node itself.
+	 * A Transition object that encapsulates the state and logic
+	 * of the transition.
 	 *
-	 * @param {Node} node
-	 * @return {Boolean}
+	 * @param {Element} el
+	 * @param {String} id
+	 * @param {Object} hooks
+	 * @param {Vue} vm
 	 */
-	
-	var doc =
-	  typeof document !== 'undefined' &&
-	  document.documentElement
-	
-	exports.inDoc = function (node) {
-	  var parent = node && node.parentNode
-	  return doc === node ||
-	    doc === parent ||
-	    !!(parent && parent.nodeType === 1 && (doc.contains(parent)))
+
+	function Transition (el, id, hooks, vm) {
+	  this.el = el
+	  this.enterClass = id + '-enter'
+	  this.leaveClass = id + '-leave'
+	  this.hooks = hooks
+	  this.vm = vm
+	  // async state
+	  this.pendingCssEvent =
+	  this.pendingCssCb =
+	  this.jsCancel =
+	  this.pendingJsCb =
+	  this.op =
+	  this.cb = null
+	  this.typeCache = {}
+	  // bind
+	  var self = this
+	  ;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone']
+	    .forEach(function (m) {
+	      self[m] = _.bind(self[m], self)
+	    })
 	}
-	
+
+	var p = Transition.prototype
+
 	/**
-	 * Extract an attribute from a node.
+	 * Start an entering transition.
 	 *
-	 * @param {Node} node
-	 * @param {String} attr
-	 */
-	
-	exports.attr = function (node, attr) {
-	  attr = config.prefix + attr
-	  var val = node.getAttribute(attr)
-	  if (val !== null) {
-	    node.removeAttribute(attr)
-	  }
-	  return val
-	}
-	
-	/**
-	 * Insert el before target
+	 * 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 {Element} el
-	 * @param {Element} target
+	 * @param {Function} op - insert/show the element
+	 * @param {Function} [cb]
 	 */
-	
-	exports.before = function (el, target) {
-	  target.parentNode.insertBefore(el, target)
+
+	p.enter = function (op, cb) {
+	  this.cancelPending()
+	  this.callHook('beforeEnter')
+	  this.cb = cb
+	  addClass(this.el, this.enterClass)
+	  op()
+	  this.callHookWithCb('enter')
+	  queue.push(this.enterNextTick)
 	}
-	
+
 	/**
-	 * Insert el after target
-	 *
-	 * @param {Element} el
-	 * @param {Element} target
+	 * 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.
 	 */
-	
-	exports.after = function (el, target) {
-	  if (target.nextSibling) {
-	    exports.before(el, target.nextSibling)
-	  } else {
-	    target.parentNode.appendChild(el)
+
+	p.enterNextTick = function () {
+	  var type = this.getCssTransitionType(this.enterClass)
+	  var enterDone = this.enterDone
+	  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 if (!this.pendingJsCb) {
+	    enterDone()
 	  }
 	}
-	
+
 	/**
-	 * Remove el from DOM
-	 *
-	 * @param {Element} el
+	 * The "cleanup" phase of an entering transition.
 	 */
-	
-	exports.remove = function (el) {
-	  el.parentNode.removeChild(el)
+
+	p.enterDone = function () {
+	  this.jsCancel = this.pendingJsCb = null
+	  removeClass(this.el, this.enterClass)
+	  this.callHook('afterEnter')
+	  if (this.cb) this.cb()
 	}
-	
+
 	/**
-	 * Prepend el to target
+	 * Start a leaving transition.
 	 *
-	 * @param {Element} el
-	 * @param {Element} target
+	 * 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]
 	 */
-	
-	exports.prepend = function (el, target) {
-	  if (target.firstChild) {
-	    exports.before(el, target.firstChild)
-	  } else {
-	    target.appendChild(el)
+
+	p.leave = function (op, cb) {
+	  this.cancelPending()
+	  this.callHook('beforeLeave')
+	  this.op = op
+	  this.cb = cb
+	  addClass(this.el, this.leaveClass)
+	  this.callHookWithCb('leave')
+	  // only need to do leaveNextTick if there's no explicit
+	  // js callback
+	  if (!this.pendingJsCb) {
+	    queue.push(this.leaveNextTick)
 	  }
 	}
-	
+
 	/**
-	 * Replace target with el
-	 *
-	 * @param {Element} target
-	 * @param {Element} el
+	 * The "nextTick" phase of a leaving transition.
 	 */
-	
-	exports.replace = function (target, el) {
-	  var parent = target.parentNode
-	  if (parent) {
-	    parent.replaceChild(el, target)
+
+	p.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()
 	  }
 	}
-	
+
 	/**
-	 * Add event listener shorthand.
-	 *
-	 * @param {Element} el
-	 * @param {String} event
-	 * @param {Function} cb
+	 * The "cleanup" phase of a leaving transition.
 	 */
-	
-	exports.on = function (el, event, cb) {
-	  el.addEventListener(event, cb)
+
+	p.leaveDone = function () {
+	  this.op()
+	  removeClass(this.el, this.leaveClass)
+	  this.callHook('afterLeave')
+	  if (this.cb) this.cb()
 	}
-	
+
 	/**
-	 * Remove event listener shorthand.
+	 * Cancel any pending callbacks from a previously running
+	 * but not finished transition.
+	 */
+
+	p.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.jsCancel) {
+	    this.jsCancel.call(null)
+	    this.jsCancel = null
+	  }
+	}
+
+	/**
+	 * Call a user-provided synchronous hook function.
 	 *
-	 * @param {Element} el
-	 * @param {String} event
-	 * @param {Function} cb
+	 * @param {String} type
 	 */
-	
-	exports.off = function (el, event, cb) {
-	  el.removeEventListener(event, cb)
+
+	p.callHook = function (type) {
+	  if (this.hooks && this.hooks[type]) {
+	    this.hooks[type].call(this.vm, this.el)
+	  }
 	}
-	
+
 	/**
-	 * Add class with compatibility for IE & SVG
+	 * 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 {Element} el
-	 * @param {Strong} cls
+	 * @param {String} type
 	 */
-	
-	exports.addClass = function (el, cls) {
-	  if (el.classList) {
-	    el.classList.add(cls)
-	  } else {
-	    var cur = ' ' + (el.getAttribute('class') || '') + ' '
-	    if (cur.indexOf(' ' + cls + ' ') < 0) {
-	      el.setAttribute('class', (cur + cls).trim())
+
+	p.callHookWithCb = function (type) {
+	  var hook = this.hooks && this.hooks[type]
+	  if (hook) {
+	    if (hook.length > 1) {
+	      this.pendingJsCb = _.cancellable(this[type + 'Done'])
 	    }
+	    this.jsCancel = hook.call(this.vm, this.el, this.pendingJsCb)
 	  }
 	}
-	
+
 	/**
-	 * Remove class with compatibility for IE & SVG
+	 * Get an element's transition type based on the
+	 * calculated styles.
 	 *
-	 * @param {Element} el
-	 * @param {Strong} cls
+	 * @param {String} className
+	 * @return {Number}
 	 */
-	
-	exports.removeClass = function (el, cls) {
-	  if (el.classList) {
-	    el.classList.remove(cls)
+
+	p.getCssTransitionType = function (className) {
+	  // 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.
+	  /* istanbul ignore if */
+	  if (!transitionEndEvent || (doc && doc.hidden)) {
+	    return
+	  }
+	  var 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 cur = ' ' + (el.getAttribute('class') || '') + ' '
-	    var tar = ' ' + cls + ' '
-	    while (cur.indexOf(tar) >= 0) {
-	      cur = cur.replace(tar, ' ')
+	    var animDuration =
+	      inlineStyles[animDurationProp] ||
+	      computedStyles[animDurationProp]
+	    if (animDuration && animDuration !== '0s') {
+	      type = TYPE_ANIMATION
 	    }
-	    el.setAttribute('class', cur.trim())
 	  }
+	  if (type) {
+	    this.typeCache[className] = type
+	  }
+	  return type
 	}
-	
+
 	/**
-	 * Extract raw content inside an element into a temporary
-	 * container div
+	 * Setup a CSS transitionend/animationend callback.
 	 *
-	 * @param {Element} el
-	 * @param {Boolean} asFragment
-	 * @return {Element}
+	 * @param {String} event
+	 * @param {Function} cb
 	 */
-	
-	exports.extractContent = function (el, asFragment) {
-	  var child
-	  var rawContent
-	  /* istanbul ignore if */
-	  if (
-	    el.tagName === 'TEMPLATE' &&
-	    el.content instanceof DocumentFragment
-	  ) {
-	    el = el.content
-	  }
-	  if (el.hasChildNodes()) {
-	    rawContent = asFragment
-	      ? document.createDocumentFragment()
-	      : document.createElement('div')
-	    /* jshint boss:true */
-	    while (child = el.firstChild) {
-	      rawContent.appendChild(child)
+
+	p.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()
+	      }
 	    }
 	  }
-	  return rawContent
+	  _.on(el, event, onEnd)
 	}
 
+	module.exports = Transition
 
 /***/ },
-/* 30 */
+/* 41 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(31)
-	
+	var _ = __webpack_require__(2)
+	var queue = []
+	var queued = false
+
 	/**
-	 * Resolve read & write filters for a vm instance. The
-	 * filters descriptor Array comes from the directive parser.
-	 *
-	 * This is extracted into its own utility so it can
-	 * be used in multiple scenarios.
+	 * Push a job into the queue.
 	 *
-	 * @param {Vue} vm
-	 * @param {Array<Object>} filters
-	 * @param {Object} [target]
-	 * @return {Object}
+	 * @param {Function} job
 	 */
-	
-	exports.resolveFilters = function (vm, filters, target) {
-	  if (!filters) {
-	    return
+
+	exports.push = function (job) {
+	  queue.push(job)
+	  if (!queued) {
+	    queued = true
+	    _.nextTick(flush)
 	  }
-	  var res = target || {}
-	  // var registry = vm.$options.filters
-	  filters.forEach(function (f) {
-	    var def = vm.$options.filters[f.name]
-	    _.assertAsset(def, 'filter', f.name)
-	    if (!def) return
-	    var args = f.args
-	    var reader, writer
-	    if (typeof def === 'function') {
-	      reader = def
-	    } else {
-	      reader = def.read
-	      writer = def.write
-	    }
-	    if (reader) {
-	      if (!res.read) res.read = []
-	      res.read.push(function (value) {
-	        return args
-	          ? reader.apply(vm, [value].concat(args))
-	          : reader.call(vm, value)
-	      })
-	    }
-	    if (writer) {
-	      if (!res.write) res.write = []
-	      res.write.push(function (value, oldVal) {
-	        return args
-	          ? writer.apply(vm, [value, oldVal].concat(args))
-	          : writer.call(vm, value, oldVal)
-	      })
-	    }
-	  })
-	  return res
 	}
-	
+
 	/**
-	 * Apply filters to a value
-	 *
-	 * @param {*} value
-	 * @param {Array} filters
-	 * @param {Vue} vm
-	 * @param {*} oldVal
-	 * @return {*}
+	 * Flush the queue, and do one forced reflow before
+	 * triggering transitions.
 	 */
-	
-	exports.applyFilters = function (value, filters, vm, oldVal) {
-	  if (!filters) {
-	    return value
-	  }
-	  for (var i = 0, l = filters.length; i < l; i++) {
-	    value = filters[i].call(vm, value, oldVal)
+
+	function flush () {
+	  // Force layout
+	  var f = document.documentElement.offsetHeight
+	  for (var i = 0; i < queue.length; i++) {
+	    queue[i]()
 	  }
-	  return value
+	  queue = []
+	  queued = false
+	  // dummy return, so js linters don't complain about
+	  // unused variable f
+	  return f
 	}
 
 /***/ },
-/* 31 */
+/* 42 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var config = __webpack_require__(15)
-	
-	/**
-	 * Enable debug utilities. The enableDebug() function and
-	 * all _.log() & _.warn() calls will be dropped in the
-	 * minified production build.
-	 */
-	
-	enableDebug()
-	
-	function enableDebug () {
-	
-	  var hasConsole = typeof console !== 'undefined'
-	  
-	  /**
-	   * Log a message.
-	   *
-	   * @param {String} msg
-	   */
-	
-	  exports.log = function (msg) {
-	    if (hasConsole && config.debug) {
-	      console.log('[Vue info]: ' + msg)
-	    }
-	  }
-	
-	  /**
-	   * We've got a problem here.
-	   *
-	   * @param {String} msg
-	   */
-	
-	  exports.warn = function (msg) {
-	    if (hasConsole && (!config.silent || config.debug)) {
-	      console.warn('[Vue warn]: ' + msg)
-	      /* istanbul ignore if */
-	      if (config.debug) {
-	        /* jshint debug: true */
-	        debugger
+	var _ = __webpack_require__(2)
+
+	module.exports = {
+
+	  acceptStatement: true,
+	  priority: 700,
+
+	  bind: function () {
+	    // 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)
 	      }
+	      _.on(this.el, 'load', this.iframeBind)
+	    }
+	  },
+
+	  update: function (handler) {
+	    if (typeof handler !== 'function') {
+	      _.warn(
+	        'Directive "v-on:' + this.expression + '" ' +
+	        'expects a function value.'
+	      )
+	      return
+	    }
+	    this.reset()
+	    var vm = this.vm
+	    this.handler = function (e) {
+	      e.targetVM = vm
+	      vm.$event = e
+	      var res = handler(e)
+	      vm.$event = null
+	      return res
+	    }
+	    if (this.iframeBind) {
+	      this.iframeBind()
+	    } else {
+	      _.on(this.el, this.arg, this.handler)
 	    }
-	  }
-	
-	  /**
-	   * Assert asset exists
-	   */
-	
-	  exports.assertAsset = function (val, type, id) {
-	    if (!val) {
-	      exports.warn('Failed to resolve ' + type + ': ' + id)
+	  },
+
+	  reset: function () {
+	    var el = this.iframeBind
+	      ? this.el.contentWindow
+	      : this.el
+	    if (this.handler) {
+	      _.off(el, this.arg, this.handler)
 	    }
+	  },
+
+	  unbind: function () {
+	    this.reset()
+	    _.off(this.el, 'load', this.iframeBind)
 	  }
 	}
 
 /***/ },
-/* 32 */
+/* 43 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    this.attr = this.el.nodeType === 3
-	      ? 'nodeValue'
-	      : 'textContent'
-	  },
-	
-	  update: function (value) {
-	    this.el[this.attr] = _.toString(value)
-	  }
-	  
-	}
+	var _ = __webpack_require__(2)
 
-/***/ },
-/* 33 */
-/***/ function(module, exports, __webpack_require__) {
+	var handlers = {
+	  text: __webpack_require__(44),
+	  radio: __webpack_require__(45),
+	  select: __webpack_require__(46),
+	  checkbox: __webpack_require__(47)
+	}
 
-	var _ = __webpack_require__(11)
-	var templateParser = __webpack_require__(20)
-	
 	module.exports = {
-	
+
+	  priority: 800,
+	  twoWay: true,
+	  handlers: handlers,
+
+	  /**
+	   * Possible elements:
+	   *   <select>
+	   *   <textarea>
+	   *   <input type="*">
+	   *     - text
+	   *     - checkbox
+	   *     - radio
+	   *     - number
+	   *     - TODO: more types may be supplied as a plugin
+	   */
+
 	  bind: function () {
-	    // a comment node means this is a binding for
-	    // {{{ inline unescaped html }}}
-	    if (this.el.nodeType === 8) {
-	      // hold nodes
-	      this.nodes = []
+	    // friendly warning...
+	    this.checkFilters()
+	    if (this.hasRead && !this.hasWrite) {
+	      _.warn(
+	        'It seems you are using a read-only filter with ' +
+	        'v-model. You might want to use a two-way filter ' +
+	        'to ensure correct behavior.'
+	      )
 	    }
-	  },
-	
-	  update: function (value) {
-	    value = _.toString(value)
-	    if (this.nodes) {
-	      this.swap(value)
+	    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 {
-	      this.el.innerHTML = value
+	      _.warn('v-model does not support element type: ' + tag)
+	      return
 	    }
+	    handler.bind.call(this)
+	    this.update = handler.update
+	    this.unbind = handler.unbind
 	  },
-	
-	  swap: function (value) {
-	    // remove old nodes
-	    var i = this.nodes.length
+
+	  /**
+	   * Check read/write filter stats.
+	   */
+
+	  checkFilters: function () {
+	    var filters = this.filters
+	    if (!filters) return
+	    var i = filters.length
 	    while (i--) {
-	      _.remove(this.nodes[i])
+	      var filter = _.resolveAsset(this.vm.$options, 'filters', filters[i].name)
+	      if (typeof filter === 'function' || filter.read) {
+	        this.hasRead = true
+	      } else if (filter.write) {
+	        this.hasWrite = true
+	      }
 	    }
-	    // convert new value to a fragment
-	    // do not attempt to retrieve from id selector
-	    var frag = templateParser.parse(value, true, true)
-	    // save a reference to these nodes so we can remove later
-	    this.nodes = _.toArray(frag.childNodes)
-	    _.before(frag, this.el)
 	  }
-	
+
 	}
 
 /***/ },
-/* 34 */
+/* 44 */
 /***/ function(module, exports, __webpack_require__) {
 
-	// xlink
-	var xlinkNS = 'http://www.w3.org/1999/xlink'
-	var xlinkRE = /^xlink:/
-	
+	var _ = __webpack_require__(2)
+
 	module.exports = {
-	
-	  priority: 850,
-	
+
 	  bind: function () {
-	    var name = this.arg
-	    this.update = xlinkRE.test(name)
-	      ? xlinkHandler
-	      : defaultHandler
-	  }
-	
-	}
-	
-	function defaultHandler (value) {
-	  if (value || value === 0) {
-	    this.el.setAttribute(this.arg, value)
-	  } else {
-	    this.el.removeAttribute(this.arg)
-	  }
-	}
-	
-	function xlinkHandler (value) {
-	  if (value != null) {
-	    this.el.setAttributeNS(xlinkNS, this.arg, value)
-	  } else {
-	    this.el.removeAttributeNS(xlinkNS, 'href')
-	  }
-	}
+	    var self = this
+	    var el = this.el
 
-/***/ },
-/* 35 */
-/***/ function(module, exports, __webpack_require__) {
+	    // check params
+	    // - lazy: update model on "change" instead of "input"
+	    var lazy = this._checkParam('lazy') != null
+	    // - number: cast value into number when updating model.
+	    var number = this._checkParam('number') != null
+	    // - debounce: debounce the input listener
+	    var debounce = parseInt(this._checkParam('debounce'), 10)
 
-	var transition = __webpack_require__(49)
-	
-	module.exports = function (value) {
-	  var el = this.el
-	  transition.apply(el, value ? 1 : -1, function () {
-	    el.style.display = value ? '' : 'none'
-	  }, this.vm)
-	}
+	    // 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) {
+	      this.onComposeStart = function () {
+	        composing = true
+	      }
+	      this.onComposeEnd = 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.
+	        self.listener()
+	      }
+	      _.on(el,'compositionstart', this.onComposeStart)
+	      _.on(el,'compositionend', this.onComposeEnd)
+	    }
 
-/***/ },
-/* 36 */
-/***/ function(module, exports, __webpack_require__) {
+	    function syncToModel () {
+	      var val = number
+	        ? _.toNumber(el.value)
+	        : el.value
+	      self.set(val)
+	    }
 
-	var _ = __webpack_require__(11)
-	var addClass = _.addClass
-	var removeClass = _.removeClass
-	
-	module.exports = function (value) {
-	  if (this.arg) {
-	    var method = value ? addClass : removeClass
-	    method(this.el, this.arg)
-	  } else {
-	    if (this.lastVal) {
-	      removeClass(this.el, this.lastVal)
+	    // if the directive has filters, we need to
+	    // record cursor position and restore it after updating
+	    // the input with the filtered value.
+	    // also force update for type="range" inputs to enable
+	    // "lock in range" (see #506)
+	    if (this.hasRead || el.type === 'range') {
+	      this.listener = function () {
+	        if (composing) return
+	        var charsOffset
+	        // some HTML5 input types throw error here
+	        try {
+	          // record how many chars from the end of input
+	          // the cursor was at
+	          charsOffset = el.value.length - el.selectionStart
+	        } catch (e) {}
+	        // Fix IE10/11 infinite update cycle
+	        // https://github.com/yyx990803/vue/issues/592
+	        /* istanbul ignore if */
+	        if (charsOffset < 0) {
+	          return
+	        }
+	        syncToModel()
+	        _.nextTick(function () {
+	          // force a value update, because in
+	          // certain cases the write filters output the
+	          // same result for different input values, and
+	          // the Observer set events won't be triggered.
+	          var newVal = self._watcher.value
+	          self.update(newVal)
+	          if (charsOffset != null) {
+	            var cursorPos =
+	              _.toString(newVal).length - charsOffset
+	            el.setSelectionRange(cursorPos, cursorPos)
+	          }
+	        })
+	      }
+	    } else {
+	      this.listener = function () {
+	        if (composing) return
+	        syncToModel()
+	      }
 	    }
-	    if (value) {
-	      addClass(this.el, value)
-	      this.lastVal = value
+
+	    if (debounce) {
+	      this.listener = _.debounce(this.listener, debounce)
 	    }
-	  }
-	}
 
-/***/ },
-/* 37 */
-/***/ function(module, exports, __webpack_require__) {
+	    // Now attach the main listener
 
-	module.exports = {
-	
-	  isLiteral: true,
-	
-	  bind: function () {
-	    this.vm.$$[this.expression] = this.el
+	    this.event = lazy ? 'change' : 'input'
+	    // 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) {
+	      jQuery(el).on(this.event, this.listener)
+	    } else {
+	      _.on(el, this.event, this.listener)
+	    }
+
+	    // IE9 doesn't fire input event on backspace/del/cut
+	    if (!lazy && _.isIE9) {
+	      this.onCut = function () {
+	        _.nextTick(self.listener)
+	      }
+	      this.onDel = function (e) {
+	        if (e.keyCode === 46 || e.keyCode === 8) {
+	          self.listener()
+	        }
+	      }
+	      _.on(el, 'cut', this.onCut)
+	      _.on(el, 'keyup', this.onDel)
+	    }
+
+	    // set initial value if present
+	    if (
+	      el.hasAttribute('value') ||
+	      (el.tagName === 'TEXTAREA' && el.value.trim())
+	    ) {
+	      this._initValue = number
+	        ? _.toNumber(el.value)
+	        : el.value
+	    }
 	  },
-	
-	  unbind: function () {
-	    delete this.vm.$$[this.expression]
-	  }
-	  
-	}
 
-/***/ },
-/* 38 */
-/***/ function(module, exports, __webpack_require__) {
+	  update: function (value) {
+	    this.el.value = _.toString(value)
+	  },
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  isLiteral: true,
-	
-	  bind: function () {
-	    var vm = this.el.__vue__
-	    if (!vm) {
-	      _.warn(
-	        'v-ref should only be used on a component root element.'
-	      )
-	      return
+	  unbind: function () {
+	    var el = this.el
+	    if (this.hasjQuery) {
+	      jQuery(el).off(this.event, this.listener)
+	    } else {
+	      _.off(el, this.event, this.listener)
+	    }
+	    if (this.onComposeStart) {
+	      _.off(el, 'compositionstart', this.onComposeStart)
+	      _.off(el, 'compositionend', this.onComposeEnd)
+	    }
+	    if (this.onCut) {
+	      _.off(el,'cut', this.onCut)
+	      _.off(el,'keyup', this.onDel)
 	    }
-	    // If we get here, it means this is a `v-ref` on a
-	    // child, because parent scope `v-ref` is stripped in
-	    // `v-component` already. So we just record our own ref
-	    // here - it will overwrite parent ref in `v-component`,
-	    // if any.
-	    vm._refID = this.expression
 	  }
-	  
 	}
 
 /***/ },
-/* 39 */
+/* 45 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var config = __webpack_require__(15)
-	
+	var _ = __webpack_require__(2)
+
 	module.exports = {
-	
+
 	  bind: function () {
+	    var self = this
 	    var el = this.el
-	    this.vm.$once('hook:compiled', function () {
-	      el.removeAttribute(config.prefix + 'cloak')
-	    })
+	    this.listener = function () {
+	      self.set(el.value)
+	    }
+	    _.on(el, 'change', this.listener)
+	    if (el.checked) {
+	      this._initValue = el.value
+	    }
+	  },
+
+	  update: function (value) {
+	    /* jshint eqeqeq: false */
+	    this.el.checked = value == this.el.value
+	  },
+
+	  unbind: function () {
+	    _.off(this.el, 'change', this.listener)
 	  }
-	
+
 	}
 
 /***/ },
-/* 40 */
+/* 46 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var prefixes = ['-webkit-', '-moz-', '-ms-']
-	var camelPrefixes = ['Webkit', 'Moz', 'ms']
-	var importantRE = /!important;?$/
-	var camelRE = /([a-z])([A-Z])/g
-	var testEl = null
-	var propCache = {}
-	
+	var _ = __webpack_require__(2)
+	var Watcher = __webpack_require__(11)
+	var dirParser = __webpack_require__(21)
+
 	module.exports = {
-	
-	  deep: true,
-	
+
+	  bind: function () {
+	    var self = this
+	    var el = this.el
+	    // check options param
+	    var optionsParam = this._checkParam('options')
+	    if (optionsParam) {
+	      initOptions.call(this, optionsParam)
+	    }
+	    this.number = this._checkParam('number') != null
+	    this.multiple = el.hasAttribute('multiple')
+	    this.listener = function () {
+	      var value = self.multiple
+	        ? getMultiValue(el)
+	        : el.value
+	      value = self.number
+	        ? _.isArray(value)
+	          ? value.map(_.toNumber)
+	          : _.toNumber(value)
+	        : value
+	      self.set(value)
+	    }
+	    _.on(el, 'change', this.listener)
+	    checkInitialValue.call(this)
+	  },
+
 	  update: function (value) {
-	    if (this.arg) {
-	      this.setProp(this.arg, value)
-	    } else {
-	      if (typeof value === 'object') {
-	        // cache object styles so that only changed props
-	        // are actually updated.
-	        if (!this.cache) this.cache = {}
-	        for (var prop in value) {
-	          this.setProp(prop, value[prop])
-	          /* jshint eqeqeq: false */
-	          if (value[prop] != this.cache[prop]) {
-	            this.cache[prop] = value[prop]
-	            this.setProp(prop, value[prop])
-	          }
-	        }
-	      } else {
-	        this.el.style.cssText = value
-	      }
+	    /* jshint eqeqeq: false */
+	    var el = this.el
+	    el.selectedIndex = -1
+	    var multi = this.multiple && _.isArray(value)
+	    var options = el.options
+	    var i = options.length
+	    var option
+	    while (i--) {
+	      option = options[i]
+	      option.selected = multi
+	        ? indexOf(value, option.value) > -1
+	        : value == option.value
 	    }
 	  },
-	
-	  setProp: function (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) {
-	        value = value.replace(importantRE, '').trim()
-	      }
-	      this.el.style.setProperty(prop, value, isImportant)
-	    } else {
-	      this.el.style.removeProperty(prop)
+
+	  unbind: function () {
+	    _.off(this.el, 'change', this.listener)
+	    if (this.optionWatcher) {
+	      this.optionWatcher.teardown()
 	    }
 	  }
-	
+
 	}
-	
+
 	/**
-	 * Normalize a CSS property name.
-	 * - cache result
-	 * - auto prefix
-	 * - camelCase -> dash-case
+	 * Initialize the option list from the param.
 	 *
-	 * @param {String} prop
-	 * @return {String}
+	 * @param {String} expression
 	 */
-	
-	function normalize (prop) {
-	  if (propCache[prop]) {
-	    return propCache[prop]
+
+	function initOptions (expression) {
+	  var self = this
+	  var descriptor = dirParser.parse(expression)[0]
+	  function optionUpdateWatcher (value) {
+	    if (_.isArray(value)) {
+	      self.el.innerHTML = ''
+	      buildOptions(self.el, value)
+	      if (self._watcher) {
+	        self.update(self._watcher.value)
+	      }
+	    } else {
+	      _.warn('Invalid options value for v-model: ' + value)
+	    }
 	  }
-	  var res = prefix(prop)
-	  propCache[prop] = propCache[res] = res
-	  return res
+	  this.optionWatcher = new Watcher(
+	    this.vm,
+	    descriptor.expression,
+	    optionUpdateWatcher,
+	    {
+	      deep: true,
+	      filters: descriptor.filters
+	    }
+	  )
+	  // update with initial value
+	  optionUpdateWatcher(this.optionWatcher.value)
 	}
-	
+
 	/**
-	 * Auto detect the appropriate prefix for a CSS property.
-	 * https://gist.github.com/paulirish/523692
+	 * Build up option elements. IE9 doesn't create options
+	 * when setting innerHTML on <select> elements, so we have
+	 * to use DOM API here.
 	 *
-	 * @param {String} prop
-	 * @return {String}
+	 * @param {Element} parent - a <select> or an <optgroup>
+	 * @param {Array} options
 	 */
-	
-	function prefix (prop) {
-	  prop = prop.replace(camelRE, '$1-$2').toLowerCase()
-	  var camel = _.camelize(prop)
-	  var upper = camel.charAt(0).toUpperCase() + camel.slice(1)
-	  if (!testEl) {
-	    testEl = document.createElement('div')
-	  }
-	  if (camel in testEl.style) {
-	    return prop
-	  }
-	  var i = prefixes.length
-	  var prefixed
-	  while (i--) {
-	    prefixed = camelPrefixes[i] + upper
-	    if (prefixed in testEl.style) {
-	      return prefixes[i] + prop
+
+	function buildOptions (parent, options) {
+	  var op, el
+	  for (var i = 0, l = options.length; i < l; i++) {
+	    op = options[i]
+	    if (!op.options) {
+	      el = document.createElement('option')
+	      if (typeof op === 'string') {
+	        el.text = el.value = op
+	      } else {
+	        /* jshint eqeqeq: false */
+	        if (op.value != null) {
+	          el.value = op.value
+	        }
+	        el.text = op.text || op.value || ''
+	        if (op.disabled) {
+	          el.disabled = true
+	        }
+	      }
+	    } else {
+	      el = document.createElement('optgroup')
+	      el.label = op.label
+	      buildOptions(el, op.options)
 	    }
+	    parent.appendChild(el)
 	  }
 	}
 
-/***/ },
-/* 41 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Check the initial value for selected options.
+	 */
 
-	var _ = __webpack_require__(11)
-	var templateParser = __webpack_require__(20)
-	var vIf = __webpack_require__(46)
-	
-	module.exports = {
-	
-	  isLiteral: true,
-	
-	  // same logic reuse from v-if
-	  compile: vIf.compile,
-	  teardown: vIf.teardown,
-	  getContainedComponents: vIf.getContainedComponents,
-	  unbind: vIf.unbind,
-	
-	  bind: function () {
-	    var el = this.el
-	    this.start = document.createComment('v-partial-start')
-	    this.end = document.createComment('v-partial-end')
-	    if (el.nodeType !== 8) {
-	      el.innerHTML = ''
-	    }
-	    if (el.tagName === 'TEMPLATE' || el.nodeType === 8) {
-	      _.replace(el, this.end)
-	    } else {
-	      el.appendChild(this.end)
-	    }
-	    _.before(this.start, this.end)
-	    if (!this._isDynamicLiteral) {
-	      this.insert(this.expression)
-	    }
-	  },
-	
-	  update: function (id) {
-	    this.teardown()
-	    this.insert(id)
-	  },
-	
-	  insert: function (id) {
-	    var partial = this.vm.$options.partials[id]
-	    _.assertAsset(partial, 'partial', id)
-	    if (partial) {
-	      var filters = this.filters && this.filters.read
-	      if (filters) {
-	        partial = _.applyFilters(partial, filters, this.vm)
+	function checkInitialValue () {
+	  var initValue
+	  var options = this.el.options
+	  for (var i = 0, l = options.length; i < l; i++) {
+	    if (options[i].hasAttribute('selected')) {
+	      if (this.multiple) {
+	        (initValue || (initValue = []))
+	          .push(options[i].value)
+	      } else {
+	        initValue = options[i].value
 	      }
-	      this.compile(templateParser.parse(partial, true))
 	    }
 	  }
-	
+	  if (typeof initValue !== 'undefined') {
+	    this._initValue = this.number
+	      ? _.toNumber(initValue)
+	      : initValue
+	  }
+	}
+
+	/**
+	 * Helper to extract a value array for select[multiple]
+	 *
+	 * @param {SelectElement} el
+	 * @return {Array}
+	 */
+
+	function getMultiValue (el) {
+	  return Array.prototype.filter
+	    .call(el.options, filterSelected)
+	    .map(getOptionValue)
+	}
+
+	function filterSelected (op) {
+	  return op.selected
 	}
 
-/***/ },
-/* 42 */
-/***/ function(module, exports, __webpack_require__) {
-
-	module.exports = {
-	
-	  priority: 1000,
-	  isLiteral: true,
-	
-	  bind: function () {
-	    if (!this._isDynamicLiteral) {
-	      this.update(this.expression)
-	    }
-	  },
-	
-	  update: function (id) {
-	    var vm = this.el.__vue__ || this.vm
-	    this.el.__v_trans = {
-	      id: id,
-	      // resolve the custom transition functions now
-	      // so the transition module knows this is a
-	      // javascript transition without having to check
-	      // computed CSS.
-	      fns: vm.$options.transitions[id]
-	    }
-	  }
-	
+	function getOptionValue (op) {
+	  return op.value || op.text
 	}
 
-/***/ },
-/* 43 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Native Array.indexOf uses strict equal, but in this
+	 * case we need to match string/numbers with soft equal.
+	 *
+	 * @param {Array} arr
+	 * @param {*} val
+	 */
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  acceptStatement: true,
-	  priority: 700,
-	
-	  bind: function () {
-	    // 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)
-	      }
-	      _.on(this.el, 'load', this.iframeBind)
-	    }
-	  },
-	
-	  update: function (handler) {
-	    if (typeof handler !== 'function') {
-	      _.warn(
-	        'Directive "v-on:' + this.expression + '" ' +
-	        'expects a function value.'
-	      )
-	      return
-	    }
-	    this.reset()
-	    var vm = this.vm
-	    this.handler = function (e) {
-	      e.targetVM = vm
-	      vm.$event = e
-	      var res = handler(e)
-	      vm.$event = null
-	      return res
-	    }
-	    if (this.iframeBind) {
-	      this.iframeBind()
-	    } else {
-	      _.on(this.el, this.arg, this.handler)
-	    }
-	  },
-	
-	  reset: function () {
-	    var el = this.iframeBind
-	      ? this.el.contentWindow
-	      : this.el
-	    if (this.handler) {
-	      _.off(el, this.arg, this.handler)
-	    }
-	  },
-	
-	  unbind: function () {
-	    this.reset()
-	    _.off(this.el, 'load', this.iframeBind)
+	function indexOf (arr, val) {
+	  /* jshint eqeqeq: false */
+	  var i = arr.length
+	  while (i--) {
+	    if (arr[i] == val) return i
 	  }
+	  return -1
 	}
 
 /***/ },
-/* 44 */
+/* 47 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var templateParser = __webpack_require__(20)
-	
+	var _ = __webpack_require__(2)
+
 	module.exports = {
-	
-	  isLiteral: true,
-	
-	  /**
-	   * Setup. Two possible usages:
-	   *
-	   * - static:
-	   *   v-component="comp"
-	   *
-	   * - dynamic:
-	   *   v-component="{{currentView}}"
-	   */
-	
+
 	  bind: function () {
-	    if (!this.el.__vue__) {
-	      // create a ref anchor
-	      this.ref = document.createComment('v-component')
-	      _.replace(this.el, this.ref)
-	      // check keep-alive options.
-	      // If yes, instead of destroying the active vm when
-	      // hiding (v-if) or switching (dynamic literal) it,
-	      // we simply remove it from the DOM and save it in a
-	      // cache object, with its constructor id as the key.
-	      this.keepAlive = this._checkParam('keep-alive') != null
-	      // check ref
-	      this.refID = _.attr(this.el, 'ref')
-	      if (this.keepAlive) {
-	        this.cache = {}
-	      }
-	      // check inline-template
-	      if (this._checkParam('inline-template') !== null) {
-	        // extract inline template as a DocumentFragment
-	        this.template = _.extractContent(this.el, true)
-	      }
-	      // if static, build right now.
-	      if (!this._isDynamicLiteral) {
-	        this.resolveCtor(this.expression, _.bind(function () {
-	          var child = this.build()
-	          child.$before(this.ref)
-	          this.setCurrent(child)
-	        }, this))
-	      } else {
-	        // check dynamic component params
-	        this.readyEvent = this._checkParam('wait-for')
-	        this.transMode = this._checkParam('transition-mode')
-	      }
-	    } else {
-	      _.warn(
-	        'v-component="' + this.expression + '" cannot be ' +
-	        'used on an already mounted instance.'
-	      )
-	    }
-	  },
-	
-	  /**
-	   * Resolve the component constructor to use when creating
-	   * the child vm.
-	   */
-	
-	  resolveCtor: function (id, cb) {
-	    var self = this
-	    // TODO handle update/teardown before the component
-	    // is actually resolved
-	    this.vm._resolveComponent(id, function (ctor) {
-	      self.ctorId = id
-	      self.Ctor = ctor
-	      cb()
-	    })
-	  },
-	
-	  /**
-	   * Instantiate/insert a new child vm.
-	   * If keep alive and has cached instance, insert that
-	   * instance; otherwise build a new one and cache it.
-	   *
-	   * @return {Vue} - the created instance
-	   */
-	
-	  build: function () {
-	    if (this.keepAlive) {
-	      var cached = this.cache[this.ctorId]
-	      if (cached) {
-	        return cached
-	      }
-	    }
-	    var vm = this.vm
-	    var el = templateParser.clone(this.el)
-	    if (this.Ctor) {
-	      var child = vm.$addChild({
-	        el: el,
-	        template: this.template,
-	        _asComponent: true,
-	        _host: this._host
-	      }, this.Ctor)
-	      if (this.keepAlive) {
-	        this.cache[this.ctorId] = child
-	      }
-	      return child
-	    }
-	  },
-	
-	  /**
-	   * Teardown the current child, but defers cleanup so
-	   * that we can separate the destroy and removal steps.
-	   */
-	
-	  unbuild: function () {
-	    var child = this.childVM
-	    if (!child || this.keepAlive) {
-	      return
-	    }
-	    // the sole purpose of `deferCleanup` is so that we can
-	    // "deactivate" the vm right now and perform DOM removal
-	    // later.
-	    child.$destroy(false, true)
-	  },
-	
-	  /**
-	   * Remove current destroyed child and manually do
-	   * the cleanup after removal.
-	   *
-	   * @param {Function} cb
-	   */
-	
-	  remove: function (child, cb) {
-	    var keepAlive = this.keepAlive
-	    if (child) {
-	      child.$remove(function () {
-	        if (!keepAlive) child._cleanup()
-	        if (cb) cb()
-	      })
-	    } else if (cb) {
-	      cb()
-	    }
-	  },
-	
-	  /**
-	   * Update callback for the dynamic literal scenario,
-	   * e.g. v-component="{{view}}"
-	   */
-	
-	  update: function (value) {
-	    if (!value) {
-	      // just remove current
-	      this.unbuild()
-	      this.remove(this.childVM)
-	      this.unsetCurrent()
-	    } else {
-	      this.resolveCtor(value, _.bind(function () {
-	        this.unbuild()
-	        var newComponent = this.build()
-	        var self = this
-	        if (this.readyEvent) {
-	          newComponent.$once(this.readyEvent, function () {
-	            self.swapTo(newComponent)
-	          })
-	        } else {
-	          this.swapTo(newComponent)
-	        }
-	      }, this))
-	    }
-	  },
-	
-	  /**
-	   * Actually swap the components, depending on the
-	   * transition mode. Defaults to simultaneous.
-	   *
-	   * @param {Vue} target
-	   */
-	
-	  swapTo: function (target) {
 	    var self = this
-	    var current = this.childVM
-	    this.unsetCurrent()
-	    this.setCurrent(target)
-	    switch (self.transMode) {
-	      case 'in-out':
-	        target.$before(self.ref, function () {
-	          self.remove(current)
-	        })
-	        break
-	      case 'out-in':
-	        self.remove(current, function () {
-	          target.$before(self.ref)
-	        })
-	        break
-	      default:
-	        self.remove(current)
-	        target.$before(self.ref)
-	    }
-	  },
-	
-	  /**
-	   * Set childVM and parent ref
-	   */
-	  
-	  setCurrent: function (child) {
-	    this.childVM = child
-	    var refID = child._refID || this.refID
-	    if (refID) {
-	      this.vm.$[refID] = child
+	    var el = this.el
+	    this.listener = function () {
+	      self.set(el.checked)
 	    }
-	  },
-	
-	  /**
-	   * Unset childVM and parent ref
-	   */
-	
-	  unsetCurrent: function () {
-	    var child = this.childVM
-	    this.childVM = null
-	    var refID = (child && child._refID) || this.refID
-	    if (refID) {
-	      this.vm.$[refID] = null
+	    _.on(el, 'change', this.listener)
+	    if (el.checked) {
+	      this._initValue = el.checked
 	    }
 	  },
-	
-	  /**
-	   * Unbind.
-	   */
-	
+
+	  update: function (value) {
+	    this.el.checked = !!value
+	  },
+
 	  unbind: function () {
-	    this.unbuild()
-	    // destroy all keep-alive cached instances
-	    if (this.cache) {
-	      for (var key in this.cache) {
-	        this.cache[key].$destroy()
-	      }
-	      this.cache = null
-	    }
+	    _.off(this.el, 'change', this.listener)
 	  }
-	
+
 	}
 
 /***/ },
-/* 45 */
+/* 48 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
+	var _ = __webpack_require__(2)
 	var isObject = _.isObject
 	var isPlainObject = _.isPlainObject
-	var textParser = __webpack_require__(19)
-	var expParser = __webpack_require__(22)
-	var templateParser = __webpack_require__(20)
-	var compile = __webpack_require__(16)
-	var transclude = __webpack_require__(17)
-	var mergeOptions = __webpack_require__(14)
+	var textParser = __webpack_require__(20)
+	var expParser = __webpack_require__(16)
+	var templateParser = __webpack_require__(23)
+	var compile = __webpack_require__(22)
+	var transclude = __webpack_require__(26)
 	var uid = 0
-	
+
+	// async component resolution states
+	var UNRESOLVED = 0
+	var PENDING = 1
+	var RESOLVED = 2
+	var ABORTED = 3
+
 	module.exports = {
-	
+
 	  /**
 	   * Setup.
 	   */
-	
+
 	  bind: function () {
 	    // uid as a cache identifier
 	    this.id = '__v_repeat_' + (++uid)
-	    // we need to insert the objToArray converter
-	    // as the first read filter, because it has to be invoked
-	    // before any user filters. (can't do it in `update`)
-	    if (!this.filters) {
-	      this.filters = {}
-	    }
-	    // add the object -> array convert filter
-	    var objectConverter = _.bind(objToArray, this)
-	    if (!this.filters.read) {
-	      this.filters.read = [objectConverter]
-	    } else {
-	      this.filters.read.unshift(objectConverter)
-	    }
-	    // setup ref node
-	    this.ref = document.createComment('v-repeat')
-	    _.replace(this.el, this.ref)
+	    // setup anchor node
+	    this.anchor = _.createAnchor('v-repeat')
+	    _.replace(this.el, this.anchor)
 	    // check if this is a block repeat
 	    this.template = this.el.tagName === 'TEMPLATE'
 	      ? templateParser.parse(this.el, true)
@@ -6484,11 +6721,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	      this._checkParam('trackby') // 0.11.0 compat
 	    this.cache = Object.create(null)
 	  },
-	
+
 	  /**
 	   * Warn against v-if usage.
 	   */
-	
+
 	  checkIf: function () {
 	    if (_.attr(this.el, 'if') !== null) {
 	      _.warn(
@@ -6497,11 +6734,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	      )
 	    }
 	  },
-	
+
 	  /**
 	   * Check if v-ref/ v-el is also present.
 	   */
-	
+
 	  checkRef: function () {
 	    var refID = _.attr(this.el, 'ref')
 	    this.refID = refID
@@ -6512,16 +6749,17 @@ return /******/ (function(modules) { // webpackBootstrap
 	      ? this.vm.$interpolate(elId)
 	      : null
 	  },
-	
+
 	  /**
 	   * Check the component constructor to use for repeated
 	   * instances. If static we resolve it now, otherwise it
 	   * needs to be resolved at build time with actual data.
 	   */
-	
+
 	  checkComponent: function () {
-	    var id = _.attr(this.el, 'component')
+	    this.componentState = UNRESOLVED
 	    var options = this.vm.$options
+	    var id = _.checkComponent(this.el, options)
 	    if (!id) {
 	      // default constructor
 	      this.Ctor = _.Vue
@@ -6534,6 +6772,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      copy._asComponent = false
 	      this._linkFn = compile(this.template, copy)
 	    } else {
+	      this.Ctor = null
 	      this.asComponent = true
 	      // check inline-template
 	      if (this._checkParam('inline-template') !== null) {
@@ -6541,44 +6780,112 @@ return /******/ (function(modules) { // webpackBootstrap
 	        this.inlineTempalte = _.extractContent(this.el, true)
 	      }
 	      var tokens = textParser.parse(id)
-	      if (!tokens) { // static component
-	        var Ctor = this.Ctor = options.components[id]
-	        _.assertAsset(Ctor, 'component', id)
-	        var merged = mergeOptions(Ctor.options, {}, {
-	          $parent: this.vm
-	        })
-	        merged.template = this.inlineTempalte || merged.template
-	        merged._asComponent = true
-	        merged._parent = this.vm
-	        this.template = transclude(this.template, merged)
-	        // Important: mark the template as a root node so that
-	        // custom element components don't get compiled twice.
-	        // fixes #822
-	        this.template.__vue__ = true
-	        this._linkFn = compile(this.template, merged)
-	      } else {
-	        // to be resolved later
+	      if (tokens) {
+	        // dynamic component to be resolved later
 	        var ctorExp = textParser.tokensToExp(tokens)
 	        this.ctorGetter = expParser.parse(ctorExp).get
+	      } else {
+	        // static
+	        this.componentId = id
+	        this.pendingData = null
+	      }
+	    }
+	  },
+
+	  resolveComponent: function () {
+	    this.componentState = PENDING
+	    this.vm._resolveComponent(this.componentId, _.bind(function (Ctor) {
+	      if (this.componentState === ABORTED) {
+	        return
 	      }
+	      this.Ctor = Ctor
+	      var merged = _.mergeOptions(Ctor.options, {}, {
+	        $parent: this.vm
+	      })
+	      merged.template = this.inlineTempalte || merged.template
+	      merged._asComponent = true
+	      merged._parent = this.vm
+	      this.template = transclude(this.template, merged)
+	      // Important: mark the template as a root node so that
+	      // custom element components don't get compiled twice.
+	      // fixes #822
+	      this.template.__vue__ = true
+	      this._linkFn = compile(this.template, merged)
+	      this.componentState = RESOLVED
+	      this.realUpdate(this.pendingData)
+	      this.pendingData = null
+	    }, this))
+	  },
+
+	    /**
+	   * Resolve a dynamic component to use for an instance.
+	   * The tricky part here is that there could be dynamic
+	   * components depending on instance data.
+	   *
+	   * @param {Object} data
+	   * @param {Object} meta
+	   * @return {Function}
+	   */
+
+	  resolveDynamicComponent: function (data, meta) {
+	    // create a temporary context object and copy data
+	    // and meta properties onto it.
+	    // use _.define to avoid accidentally overwriting scope
+	    // properties.
+	    var context = Object.create(this.vm)
+	    var key
+	    for (key in data) {
+	      _.define(context, key, data[key])
+	    }
+	    for (key in meta) {
+	      _.define(context, key, meta[key])
+	    }
+	    var id = this.ctorGetter.call(context, context)
+	    var Ctor = _.resolveAsset(this.vm.$options, 'components', id)
+	    _.assertAsset(Ctor, 'component', id)
+	    if (!Ctor.options) {
+	      _.warn(
+	        'Async resolution is not supported for v-repeat ' +
+	        '+ dynamic component. (component: ' + id + ')'
+	      )
+	      return _.Vue
 	    }
+	    return Ctor
 	  },
-	
+
 	  /**
 	   * Update.
-	   * This is called whenever the Array mutates.
+	   * This is called whenever the Array mutates. If we have
+	   * a component, we might need to wait for it to resolve
+	   * asynchronously.
 	   *
 	   * @param {Array|Number|String} data
 	   */
-	
+
 	  update: function (data) {
-	    data = data || []
-	    var type = typeof data
-	    if (type === 'number') {
-	      data = range(data)
-	    } else if (type === 'string') {
-	      data = _.toArray(data)
+	    if (this.componentId) {
+	      var state = this.componentState
+	      if (state === UNRESOLVED) {
+	        this.pendingData = data
+	        // once resolved, it will call realUpdate
+	        this.resolveComponent()
+	      } else if (state === PENDING) {
+	        this.pendingData = data
+	      } else if (state === RESOLVED) {
+	        this.realUpdate(data)
+	      }
+	    } else {
+	      this.realUpdate(data)
 	    }
+	  },
+
+	  /**
+	   * The real update that actually modifies the DOM.
+	   *
+	   * @param {Array|Number|String} data
+	   */
+
+	  realUpdate: function (data) {
 	    this.vms = this.diff(data, this.vms)
 	    // update v-ref
 	    if (this.refID) {
@@ -6590,7 +6897,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      })
 	    }
 	  },
-	
+
 	  /**
 	   * Diff, based on new data and old data, determine the
 	   * minimum amount of DOM manipulations needed to make the
@@ -6606,11 +6913,11 @@ return /******/ (function(modules) { // webpackBootstrap
 	   * @param {Array} oldVms
 	   * @return {Array}
 	   */
-	
+
 	  diff: function (data, oldVms) {
 	    var idKey = this.idKey
 	    var converted = this.converted
-	    var ref = this.ref
+	    var anchor = this.anchor
 	    var alias = this.arg
 	    var init = !oldVms
 	    var vms = new Array(data.length)
@@ -6622,29 +6929,34 @@ return /******/ (function(modules) { // webpackBootstrap
 	    for (i = 0, l = data.length; i < l; i++) {
 	      obj = data[i]
 	      raw = converted ? obj.$value : obj
-	      vm = !init && this.getVm(raw)
+	      vm = !init && this.getVm(raw, i, converted ? obj.$key : null)
 	      if (vm) { // reusable instance
 	        vm._reused = true
 	        vm.$index = i // update $index
-	        if (converted) {
-	          vm.$key = obj.$key // update $key
-	        }
-	        if (idKey) { // swap track by id data
+	        // update data for track-by or object repeat,
+	        // since in these two cases the data is replaced
+	        // rather than mutated.
+	        if (idKey || converted) {
 	          if (alias) {
 	            vm[alias] = raw
+	          } else if (_.isPlainObject(raw)) {
+	            vm.$data = raw
 	          } else {
-	            vm._setData(raw)
+	            vm.$value = raw
 	          }
 	        }
 	      } else { // new instance
 	        vm = this.build(obj, i, true)
-	        vm._new = true
+	        // the _new flag is used in the second pass for
+	        // vm cache retrival, but if this is the init phase
+	        // the flag can just be set to false directly.
+	        vm._new = !init
 	        vm._reused = false
 	      }
 	      vms[i] = vm
 	      // insert if this is first run
 	      if (init) {
-	        vm.$before(ref)
+	        vm.$before(anchor)
 	      }
 	    }
 	    // if this is the first run, we're done.
@@ -6677,13 +6989,13 @@ return /******/ (function(modules) { // webpackBootstrap
 	        // place, so no need to touch it. Otherwise, insert
 	        // it.
 	        if (!vm._reused) {
-	          vm.$before(ref)
+	          vm.$before(anchor)
 	        }
 	      } else {
 	        var nextEl = targetNext.$el
 	        if (vm._reused) {
 	          // this is the vm we are actually in front of
-	          currentNext = findNextVm(vm, ref)
+	          currentNext = findNextVm(vm, anchor)
 	          // we only need to move if we are not in the right
 	          // place already.
 	          if (currentNext !== targetNext) {
@@ -6699,7 +7011,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	    }
 	    return vms
 	  },
-	
+
 	  /**
 	   * Build a new instance and cache it.
 	   *
@@ -6707,7 +7019,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	   * @param {Number} index
 	   * @param {Boolean} needCache
 	   */
-	
+
 	  build: function (data, index, needCache) {
 	    var meta = { $index: index }
 	    if (this.converted) {
@@ -6727,7 +7039,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      data = raw
 	    }
 	    // resolve constructor
-	    var Ctor = this.Ctor || this.resolveCtor(data, meta)
+	    var Ctor = this.Ctor || this.resolveDynamicComponent(data, meta)
 	    var vm = this.vm.$addChild({
 	      el: templateParser.clone(this.template),
 	      _asComponent: this.asComponent,
@@ -6743,55 +7055,34 @@ return /******/ (function(modules) { // webpackBootstrap
 	    vm._repeat = true
 	    // cache instance
 	    if (needCache) {
-	      this.cacheVm(raw, vm)
-	    }
-	    // sync back changes for $value, particularly for
-	    // two-way bindings of primitive values
-	    var self = this
-	    vm.$watch('$value', function (val) {
-	      if (self.converted) {
-	        self.rawValue[vm.$key] = val
-	      } else {
-	        self.rawValue.$set(vm.$index, val)
-	      }
-	    })
-	    return vm
-	  },
-	
-	  /**
-	   * Resolve a contructor to use for an instance.
-	   * The tricky part here is that there could be dynamic
-	   * components depending on instance data.
-	   *
-	   * @param {Object} data
-	   * @param {Object} meta
-	   * @return {Function}
-	   */
-	
-	  resolveCtor: function (data, meta) {
-	    // create a temporary context object and copy data
-	    // and meta properties onto it.
-	    // use _.define to avoid accidentally overwriting scope
-	    // properties.
-	    var context = Object.create(this.vm)
-	    var key
-	    for (key in data) {
-	      _.define(context, key, data[key])
+	      this.cacheVm(raw, vm, index, this.converted ? meta.$key : null)
 	    }
-	    for (key in meta) {
-	      _.define(context, key, meta[key])
+	    // sync back changes for two-way bindings of primitive values
+	    var type = typeof raw
+	    var dir = this
+	    if (
+	      this.rawType === 'object' &&
+	      (type === 'string' || type === 'number')
+	    ) {
+	      vm.$watch(alias || '$value', function (val) {
+	        dir._withLock(function () {
+	          if (dir.converted) {
+	            dir.rawValue[vm.$key] = val
+	          } else {
+	            dir.rawValue.$set(vm.$index, val)
+	          }
+	        })
+	      })
 	    }
-	    var id = this.ctorGetter.call(context, context)
-	    var Ctor = this.vm.$options.components[id]
-	    _.assertAsset(Ctor, 'component', id)
-	    return Ctor
+	    return vm
 	  },
-	
+
 	  /**
 	   * Unbind, teardown everything
 	   */
-	
+
 	  unbind: function () {
+	    this.componentState = ABORTED
 	    if (this.refID) {
 	      this.vm.$[this.refID] = null
 	    }
@@ -6805,7 +7096,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	      }
 	    }
 	  },
-	
+
 	  /**
 	   * Cache a vm instance based on its data.
 	   *
@@ -6816,14 +7107,20 @@ return /******/ (function(modules) { // webpackBootstrap
 	   *
 	   * @param {Object} data
 	   * @param {Vue} vm
+	   * @param {Number} index
+	   * @param {String} [key]
 	   */
-	
-	  cacheVm: function (data, vm) {
+
+	  cacheVm: function (data, vm, index, key) {
 	    var idKey = this.idKey
 	    var cache = this.cache
 	    var id
-	    if (idKey) {
-	      id = data[idKey]
+	    if (key || idKey) {
+	      id = idKey
+	        ? idKey === '$index'
+	          ? index
+	          : data[idKey]
+	        : key
 	      if (!cache[id]) {
 	        cache[id] = vm
 	      } else {
@@ -6841,1799 +7138,1816 @@ return /******/ (function(modules) { // webpackBootstrap
 	          )
 	        }
 	      } else {
-	        _.define(data, this.id, vm)
+	        _.define(data, id, vm)
 	      }
 	    } else {
 	      if (!cache[data]) {
 	        cache[data] = [vm]
 	      } else {
-	        cache[data].push(vm)
+	        cache[data].push(vm)
+	      }
+	    }
+	    vm._raw = data
+	  },
+
+	  /**
+	   * Try to get a cached instance from a piece of data.
+	   *
+	   * @param {Object} data
+	   * @param {Number} index
+	   * @param {String} [key]
+	   * @return {Vue|undefined}
+	   */
+
+	  getVm: function (data, index, key) {
+	    var idKey = this.idKey
+	    if (key || idKey) {
+	      var id = idKey
+	        ? idKey === '$index'
+	          ? index
+	          : data[idKey]
+	        : key
+	      return this.cache[id]
+	    } else if (isObject(data)) {
+	      return data[this.id]
+	    } else {
+	      var cached = this.cache[data]
+	      if (cached) {
+	        var i = 0
+	        var vm = cached[i]
+	        // since duplicated vm instances might be a reused
+	        // one OR a newly created one, we need to return the
+	        // first instance that is neither of these.
+	        while (vm && (vm._reused || vm._new)) {
+	          vm = cached[++i]
+	        }
+	        return vm
+	      }
+	    }
+	  },
+
+	  /**
+	   * Delete a cached vm instance.
+	   *
+	   * @param {Vue} vm
+	   */
+
+	  uncacheVm: function (vm) {
+	    var data = vm._raw
+	    var idKey = this.idKey
+	    var convertedKey = vm.$key
+	    if (idKey || convertedKey) {
+	      var id = idKey
+	        ? idKey === '$index'
+	          ? vm.$index
+	          : data[idKey]
+	        : convertedKey
+	      this.cache[id] = null
+	    } else if (isObject(data)) {
+	      data[this.id] = null
+	      vm._raw = null
+	    } else {
+	      this.cache[data].pop()
+	    }
+	  },
+
+	  /**
+	   * Pre-process the value before piping it through the
+	   * filters, and convert non-Array objects to arrays.
+	   *
+	   * This function will be bound to this directive instance
+	   * and passed into the watcher.
+	   *
+	   * @param {*} value
+	   * @return {Array}
+	   * @private
+	   */
+
+	  _preProcess: function (value) {
+	    // regardless of type, store the un-filtered raw value.
+	    this.rawValue = value
+	    var type = this.rawType = typeof value
+	    if (!isPlainObject(value)) {
+	      this.converted = false
+	      if (type === 'number') {
+	        value = range(value)
+	      } else if (type === 'string') {
+	        value = _.toArray(value)
+	      }
+	      return value || []
+	    } else {
+	      // 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]
+	        }
+	      }
+	      this.converted = true
+	      return res
+	    }
+	  }
+
+	}
+
+	/**
+	 * Helper to find the next element that is an instance
+	 * root node. This is necessary because a destroyed vm's
+	 * element could still be lingering in the DOM before its
+	 * leaving transition finishes, but its __vue__ reference
+	 * should have been removed so we can skip them.
+	 *
+	 * @param {Vue} vm
+	 * @param {Comment|Text} anchor
+	 * @return {Vue}
+	 */
+
+	function findNextVm (vm, anchor) {
+	  var el = (vm._blockEnd || vm.$el).nextSibling
+	  while (!el.__vue__ && el !== anchor) {
+	    el = el.nextSibling
+	  }
+	  return el.__vue__
+	}
+
+	/**
+	 * Create a range array from given number.
+	 *
+	 * @param {Number} n
+	 * @return {Array}
+	 */
+
+	function range (n) {
+	  var i = -1
+	  var ret = new Array(n)
+	  while (++i < n) {
+	    ret[i] = i
+	  }
+	  return ret
+	}
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+	var compile = __webpack_require__(22)
+	var templateParser = __webpack_require__(23)
+	var transition = __webpack_require__(33)
+
+	module.exports = {
+
+	  bind: function () {
+	    var el = this.el
+	    if (!el.__vue__) {
+	      this.start = _.createAnchor('v-if-start')
+	      this.end = _.createAnchor('v-if-end')
+	      _.replace(el, this.end)
+	      _.before(this.start, this.end)
+	      if (el.tagName === 'TEMPLATE') {
+	        this.template = templateParser.parse(el, true)
+	      } else {
+	        this.template = document.createDocumentFragment()
+	        this.template.appendChild(templateParser.clone(el))
 	      }
+	      // compile the nested partial
+	      this.linker = compile(
+	        this.template,
+	        this.vm.$options,
+	        true
+	      )
+	    } else {
+	      this.invalid = true
+	      _.warn(
+	        'v-if="' + this.expression + '" cannot be ' +
+	        'used on an already mounted instance.'
+	      )
 	    }
-	    vm._raw = data
 	  },
-	
-	  /**
-	   * Try to get a cached instance from a piece of data.
-	   *
-	   * @param {Object} data
-	   * @return {Vue|undefined}
-	   */
-	
-	  getVm: function (data) {
-	    if (this.idKey) {
-	      return this.cache[data[this.idKey]]
-	    } else if (isObject(data)) {
-	      return data[this.id]
+
+	  update: function (value) {
+	    if (this.invalid) return
+	    if (value) {
+	      // avoid duplicate compiles, since update() can be
+	      // called with different truthy values
+	      if (!this.unlink) {
+	        this.compile()
+	      }
 	    } else {
-	      var cached = this.cache[data]
-	      if (cached) {
-	        var i = 0
-	        var vm = cached[i]
-	        // since duplicated vm instances might be a reused
-	        // one OR a newly created one, we need to return the
-	        // first instance that is neither of these.
-	        while (vm && (vm._reused || vm._new)) {
-	          vm = cached[++i]
+	      this.teardown()
+	    }
+	  },
+
+	  compile: function () {
+	    var vm = this.vm
+	    var frag = templateParser.clone(this.template)
+	    // the linker is not guaranteed to be present because
+	    // this function might get called by v-partial 
+	    this.unlink = this.linker(vm, frag)
+	    transition.blockAppend(frag, this.end, vm)
+	    // call attached for all the child components created
+	    // during the compilation
+	    if (_.inDoc(vm.$el)) {
+	      var children = this.getContainedComponents()
+	      if (children) children.forEach(callAttach)
+	    }
+	  },
+
+	  teardown: function () {
+	    if (!this.unlink) return
+	    // collect children beforehand
+	    var children
+	    if (_.inDoc(this.vm.$el)) {
+	      children = this.getContainedComponents()
+	    }
+	    transition.blockRemove(this.start, this.end, this.vm)
+	    if (children) children.forEach(callDetach)
+	    this.unlink()
+	    this.unlink = null
+	  },
+
+	  getContainedComponents: function () {
+	    var vm = this.vm
+	    var start = this.start.nextSibling
+	    var end = this.end
+	    var selfCompoents =
+	      vm._children.length &&
+	      vm._children.filter(contains)
+	    var transComponents =
+	      vm._transCpnts &&
+	      vm._transCpnts.filter(contains)
+
+	    function contains (c) {
+	      var cur = start
+	      var next
+	      while (next !== end) {
+	        next = cur.nextSibling
+	        if (cur.contains(c.$el)) {
+	          return true
 	        }
-	        return vm
+	        cur = next
 	      }
+	      return false
 	    }
+
+	    return selfCompoents
+	      ? transComponents
+	        ? selfCompoents.concat(transComponents)
+	        : selfCompoents
+	      : transComponents
 	  },
-	
-	  /**
-	   * Delete a cached vm instance.
-	   *
-	   * @param {Vue} vm
-	   */
-	
-	  uncacheVm: function (vm) {
-	    var data = vm._raw
-	    if (this.idKey) {
-	      this.cache[data[this.idKey]] = null
-	    } else if (isObject(data)) {
-	      data[this.id] = null
-	      vm._raw = null
-	    } else {
-	      this.cache[data].pop()
+
+	  unbind: function () {
+	    if (this.unlink) this.unlink()
+	  }
+
+	}
+
+	function callAttach (child) {
+	  if (!child._isAttached) {
+	    child._callHook('attached')
+	  }
+	}
+
+	function callDetach (child) {
+	  if (child._isAttached) {
+	    child._callHook('detached')
+	  }
+	}
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
+	module.exports = {
+
+	  acceptStatement: true,
+
+	  bind: function () {
+	    var child = this.el.__vue__
+	    if (!child || this.vm !== child.$parent) {
+	      _.warn(
+	        '`v-events` should only be used on a child component ' +
+	        'from the parent template.'
+	      )
+	      return
+	    }
+	  },
+
+	  update: function (handler, oldHandler) {
+	    if (typeof handler !== 'function') {
+	      _.warn(
+	        'Directive "v-events:' + this.expression + '" ' +
+	        'expects a function value.'
+	      )
+	      return
+	    }
+	    var child = this.el.__vue__
+	    if (oldHandler) {
+	      child.$off(this.arg, oldHandler)
 	    }
+	    child.$on(this.arg, handler)
 	  }
-	
+
+	  // when child is destroyed, all events are turned off,
+	  // so no need for unbind here.
+
 	}
-	
+
+/***/ },
+/* 51 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
 	/**
-	 * Helper to find the next element that is an instance
-	 * root node. This is necessary because a destroyed vm's
-	 * element could still be lingering in the DOM before its
-	 * leaving transition finishes, but its __vue__ reference
-	 * should have been removed so we can skip them.
+	 * Stringify value.
+	 *
+	 * @param {Number} indent
+	 */
+
+	exports.json = {
+	  read: function (value, indent) {
+	    return typeof value === 'string'
+	      ? value
+	      : JSON.stringify(value, null, Number(indent) || 2)
+	  },
+	  write: function (value) {
+	    try {
+	      return JSON.parse(value)
+	    } catch (e) {
+	      return value
+	    }
+	  }
+	}
+
+	/**
+	 * 'abc' => 'Abc'
+	 */
+
+	exports.capitalize = function (value) {
+	  if (!value && value !== 0) return ''
+	  value = value.toString()
+	  return value.charAt(0).toUpperCase() + value.slice(1)
+	}
+
+	/**
+	 * 'abc' => 'ABC'
+	 */
+
+	exports.uppercase = function (value) {
+	  return (value || value === 0)
+	    ? value.toString().toUpperCase()
+	    : ''
+	}
+
+	/**
+	 * 'AbC' => 'abc'
+	 */
+
+	exports.lowercase = function (value) {
+	  return (value || value === 0)
+	    ? value.toString().toLowerCase()
+	    : ''
+	}
+
+	/**
+	 * 12345 => $12,345.00
+	 *
+	 * @param {String} sign
+	 */
+
+	var digitsRE = /(\d{3})(?=\d)/g
+
+	exports.currency = function (value, sign) {
+	  value = parseFloat(value)
+	  if (!isFinite(value) || (!value && value !== 0)) return ''
+	  sign = sign || '$'
+	  var s = Math.floor(Math.abs(value)).toString(),
+	    i = s.length % 3,
+	    h = i > 0
+	      ? (s.slice(0, i) + (s.length > 3 ? ',' : ''))
+	      : '',
+	    v = Math.abs(parseInt((value * 100) % 100, 10)),
+	    f = '.' + (v < 10 ? ('0' + v) : v)
+	  return (value < 0 ? '-' : '') +
+	    sign + h + s.slice(i).replace(digitsRE, '$1,') + f
+	}
+
+	/**
+	 * '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.
 	 *
-	 * @param {Vue} vm
-	 * @param {CommentNode} ref
-	 * @return {Vue}
+	 *  e.g. ['single', 'double', 'triple', 'multiple']
 	 */
-	
-	function findNextVm (vm, ref) {
-	  var el = (vm._blockEnd || vm.$el).nextSibling
-	  while (!el.__vue__ && el !== ref) {
-	    el = el.nextSibling
-	  }
-	  return el.__vue__
+
+	exports.pluralize = function (value) {
+	  var args = _.toArray(arguments, 1)
+	  return args.length > 1
+	    ? (args[value % 10 - 1] || args[args.length - 1])
+	    : (args[0] + (value === 1 ? '' : 's'))
 	}
-	
+
 	/**
-	 * Attempt to convert non-Array objects to array.
-	 * This is the default filter installed to every v-repeat
-	 * directive.
-	 *
-	 * It will be called with **the directive** as `this`
-	 * context so that we can mark the repeat array as converted
-	 * from an object.
+	 * A special filter that takes a handler function,
+	 * wraps it so it only gets triggered on specific
+	 * keypresses. v-on only.
 	 *
-	 * @param {*} obj
-	 * @return {Array}
-	 * @private
+	 * @param {String} key
 	 */
-	
-	function objToArray (obj) {
-	  // regardless of type, store the un-filtered raw value.
-	  this.rawValue = obj
-	  if (!isPlainObject(obj)) {
-	    return obj
+
+	var keyCodes = {
+	  enter    : 13,
+	  tab      : 9,
+	  'delete' : 46,
+	  up       : 38,
+	  left     : 37,
+	  right    : 39,
+	  down     : 40,
+	  esc      : 27
+	}
+
+	exports.key = function (handler, key) {
+	  if (!handler) return
+	  var code = keyCodes[key]
+	  if (!code) {
+	    code = parseInt(key, 10)
 	  }
-	  var keys = Object.keys(obj)
-	  var i = keys.length
-	  var res = new Array(i)
-	  var key
-	  while (i--) {
-	    key = keys[i]
-	    res[i] = {
-	      $key: key,
-	      $value: obj[key]
+	  return function (e) {
+	    if (e.keyCode === code) {
+	      return handler.call(this, e)
 	    }
 	  }
-	  // `this` points to the repeat directive instance
-	  this.converted = true
-	  return res
 	}
-	
+
+	// expose keycode hash
+	exports.key.keyCodes = keyCodes
+
 	/**
-	 * Create a range array from given number.
-	 *
-	 * @param {Number} n
-	 * @return {Array}
+	 * Install special array filters
 	 */
-	
-	function range (n) {
-	  var i = -1
-	  var ret = new Array(n)
-	  while (++i < n) {
-	    ret[i] = i
-	  }
-	  return ret
-	}
+
+	_.extend(exports, __webpack_require__(52))
+
 
 /***/ },
-/* 46 */
+/* 52 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var compile = __webpack_require__(16)
-	var templateParser = __webpack_require__(20)
-	var transition = __webpack_require__(49)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    var el = this.el
-	    if (!el.__vue__) {
-	      this.start = document.createComment('v-if-start')
-	      this.end = document.createComment('v-if-end')
-	      _.replace(el, this.end)
-	      _.before(this.start, this.end)
-	      if (el.tagName === 'TEMPLATE') {
-	        this.template = templateParser.parse(el, true)
-	      } else {
-	        this.template = document.createDocumentFragment()
-	        this.template.appendChild(templateParser.clone(el))
-	      }
-	      // compile the nested partial
-	      this.linker = compile(
-	        this.template,
-	        this.vm.$options,
-	        true
-	      )
-	    } else {
-	      this.invalid = true
-	      _.warn(
-	        'v-if="' + this.expression + '" cannot be ' +
-	        'used on an already mounted instance.'
-	      )
-	    }
-	  },
-	
-	  update: function (value) {
-	    if (this.invalid) return
-	    if (value) {
-	      // avoid duplicate compiles, since update() can be
-	      // called with different truthy values
-	      if (!this.unlink) {
-	        var frag = templateParser.clone(this.template)
-	        this.compile(frag)
-	      }
-	    } else {
-	      this.teardown()
-	    }
-	  },
-	
-	  // NOTE: this function is shared in v-partial
-	  compile: function (frag) {
-	    var vm = this.vm
-	    // the linker is not guaranteed to be present because
-	    // this function might get called by v-partial 
-	    this.unlink = this.linker
-	      ? this.linker(vm, frag)
-	      : vm.$compile(frag)
-	    transition.blockAppend(frag, this.end, vm)
-	    // call attached for all the child components created
-	    // during the compilation
-	    if (_.inDoc(vm.$el)) {
-	      var children = this.getContainedComponents()
-	      if (children) children.forEach(callAttach)
-	    }
-	  },
-	
-	  // NOTE: this function is shared in v-partial
-	  teardown: function () {
-	    if (!this.unlink) return
-	    // collect children beforehand
-	    var children
-	    if (_.inDoc(this.vm.$el)) {
-	      children = this.getContainedComponents()
-	    }
-	    transition.blockRemove(this.start, this.end, this.vm)
-	    if (children) children.forEach(callDetach)
-	    this.unlink()
-	    this.unlink = null
-	  },
-	
-	  // NOTE: this function is shared in v-partial
-	  getContainedComponents: function () {
-	    var vm = this.vm
-	    var start = this.start.nextSibling
-	    var end = this.end
-	    var selfCompoents =
-	      vm._children.length &&
-	      vm._children.filter(contains)
-	    var transComponents =
-	      vm._transCpnts &&
-	      vm._transCpnts.filter(contains)
-	
-	    function contains (c) {
-	      var cur = start
-	      var next
-	      while (next !== end) {
-	        next = cur.nextSibling
-	        if (cur.contains(c.$el)) {
-	          return true
-	        }
-	        cur = next
-	      }
-	      return false
-	    }
-	
-	    return selfCompoents
-	      ? transComponents
-	        ? selfCompoents.concat(transComponents)
-	        : selfCompoents
-	      : transComponents
-	  },
-	
-	  // NOTE: this function is shared in v-partial
-	  unbind: function () {
-	    if (this.unlink) this.unlink()
-	  }
-	
-	}
-	
-	function callAttach (child) {
-	  if (!child._isAttached) {
-	    child._callHook('attached')
+	var _ = __webpack_require__(2)
+	var Path = __webpack_require__(17)
+
+	/**
+	 * Filter filter for v-repeat
+	 *
+	 * @param {String} searchKey
+	 * @param {String} [delimiter]
+	 * @param {String} dataKey
+	 */
+
+	exports.filterBy = function (arr, search, delimiter, dataKey) {
+	  // allow optional `in` delimiter
+	  // because why not
+	  if (delimiter && delimiter !== 'in') {
+	    dataKey = delimiter
 	  }
-	}
-	
-	function callDetach (child) {
-	  if (child._isAttached) {
-	    child._callHook('detached')
+	  if (!search) {
+	    return arr
 	  }
+	  // cast to lowercase string
+	  search = ('' + search).toLowerCase()
+	  return arr.filter(function (item) {
+	    return dataKey
+	      ? contains(Path.get(item, dataKey), search)
+	      : contains(item, search)
+	  })
 	}
 
-/***/ },
-/* 47 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Filter filter for v-repeat
+	 *
+	 * @param {String} sortKey
+	 * @param {String} reverse
+	 */
 
-	var _ = __webpack_require__(11)
-	var Watcher = __webpack_require__(25)
-	var expParser = __webpack_require__(22)
-	var literalRE = /^(true|false|\s?('[^']*'|"[^"]")\s?)$/
-	
-	module.exports = {
-	
-	  priority: 900,
-	
-	  bind: function () {
-	
-	    var child = this.vm
-	    var parent = child.$parent
-	    var childKey = this.arg || '$data'
-	    var parentKey = this.expression
-	
-	    if (this.el && this.el !== child.$el) {
-	      _.warn(
-	        'v-with can only be used on instance root elements.'
-	      )
-	    } else if (!parent) {
-	      _.warn(
-	        'v-with must be used on an instance with a parent.'
-	      )
-	    } else if (literalRE.test(parentKey)) {
-	      // no need to setup watchers for literal bindings
-	      if (!this.arg) {
-	        _.warn(
-	          'v-with cannot bind literal value as $data: ' +
-	          parentKey
-	        )
-	      } else {
-	        var value = expParser.parse(parentKey).get()
-	        child.$set(childKey, value)
-	      }
+	exports.orderBy = function (arr, sortKey, reverse) {
+	  if (!sortKey) {
+	    return arr
+	  }
+	  var order = 1
+	  if (arguments.length > 2) {
+	    if (reverse === '-1') {
+	      order = -1
 	    } else {
-	
-	      // simple lock to avoid circular updates.
-	      // without this it would stabilize too, but this makes
-	      // sure it doesn't cause other watchers to re-evaluate.
-	      var locked = false
-	      var lock = function () {
-	        locked = true
-	        _.nextTick(unlock)
-	      }
-	      var unlock = function () {
-	        locked = false
-	      }
-	
-	      this.parentWatcher = new Watcher(
-	        parent,
-	        parentKey,
-	        function (val) {
-	          if (!locked) {
-	            lock()
-	            child.$set(childKey, val)
-	          }
-	        }
-	      )
-	      
-	      // set the child initial value first, before setting
-	      // up the child watcher to avoid triggering it
-	      // immediately.
-	      child.$set(childKey, this.parentWatcher.value)
-	
-	      this.childWatcher = new Watcher(
-	        child,
-	        childKey,
-	        function (val) {
-	          if (!locked) {
-	            lock()
-	            parent.$set(parentKey, val)
-	          }
-	        }
-	      )
+	      order = reverse ? -1 : 1
 	    }
-	  },
-	
-	  unbind: function () {
-	    if (this.parentWatcher) {
-	      this.parentWatcher.teardown()
-	      this.childWatcher.teardown()
+	  }
+	  // sort on a copy to avoid mutating original array
+	  return arr.slice().sort(function (a, b) {
+	    if (sortKey !== '$key' && sortKey !== '$value') {
+	      if (a && '$value' in a) a = a.$value
+	      if (b && '$value' in b) b = b.$value
+	    }
+	    a = _.isObject(a) ? Path.get(a, sortKey) : a
+	    b = _.isObject(b) ? Path.get(b, sortKey) : b
+	    return a === b ? 0 : a > b ? order : -order
+	  })
+	}
+
+	/**
+	 * String contain helper
+	 *
+	 * @param {*} val
+	 * @param {String} search
+	 */
+
+	function contains (val, search) {
+	  if (_.isPlainObject(val)) {
+	    for (var key in val) {
+	      if (contains(val[key], search)) {
+	        return true
+	      }
+	    }
+	  } else if (_.isArray(val)) {
+	    var i = val.length
+	    while (i--) {
+	      if (contains(val[i], search)) {
+	        return true
+	      }
 	    }
+	  } else if (val != null) {
+	    return val.toString().toLowerCase().indexOf(search) > -1
 	  }
-	
 	}
 
 /***/ },
-/* 48 */
+/* 53 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  acceptStatement: true,
-	
-	  bind: function () {
-	    var child = this.el.__vue__
-	    if (!child || this.vm !== child.$parent) {
-	      _.warn(
-	        '`v-events` should only be used on a child component ' +
-	        'from the parent template.'
-	      )
-	      return
-	    }
-	  },
-	
-	  update: function (handler, oldHandler) {
-	    if (typeof handler !== 'function') {
-	      _.warn(
-	        'Directive "v-events:' + this.expression + '" ' +
-	        'expects a function value.'
-	      )
-	      return
-	    }
-	    var child = this.el.__vue__
-	    if (oldHandler) {
-	      child.$off(this.arg, oldHandler)
-	    }
-	    child.$on(this.arg, handler)
+	var mergeOptions = __webpack_require__(2).mergeOptions
+
+	/**
+	 * 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.
+	 */
+
+	exports._init = function (options) {
+
+	  options = options || {}
+
+	  this.$el           = null
+	  this.$parent       = options._parent
+	  this.$root         = options._root || this
+	  this.$             = {} // child vm references
+	  this.$$            = {} // element references
+	  this._watchers     = [] // all watchers as an array
+	  this._directives   = [] // all directives
+
+	  // a flag to avoid this being observed
+	  this._isVue = true
+
+	  // events bookkeeping
+	  this._events         = {}    // registered callbacks
+	  this._eventsCount    = {}    // for $broadcast optimization
+	  this._eventCancelled = false // for event cancellation
+
+	  // block instance properties
+	  this._isBlock     = false
+	  this._blockStart  =          // @type {CommentNode}
+	  this._blockEnd    = null     // @type {CommentNode}
+
+	  // lifecycle state
+	  this._isCompiled  =
+	  this._isDestroyed =
+	  this._isReady     =
+	  this._isAttached  =
+	  this._isBeingDestroyed = false
+	  this._unlinkFn    = null
+
+	  // children
+	  this._children = []
+	  this._childCtors = {}
+
+	  // transcluded components that belong to the parent.
+	  // need to keep track of them so that we can call
+	  // attached/detached hooks on them.
+	  this._transCpnts = []
+	  this._host = options._host
+
+	  // push self into parent / transclusion host
+	  if (this.$parent) {
+	    this.$parent._children.push(this)
+	  }
+	  if (this._host) {
+	    this._host._transCpnts.push(this)
+	  }
+
+	  // props used in v-repeat diffing
+	  this._new = true
+	  this._reused = false
+
+	  // merge options.
+	  options = this.$options = mergeOptions(
+	    this.constructor.options,
+	    options,
+	    this
+	  )
+
+	  // set data after merge.
+	  this._data = options.data || {}
+
+	  // initialize data observation and scope inheritance.
+	  this._initScope()
+
+	  // 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)
 	  }
-	
-	  // when child is destroyed, all events are turned off,
-	  // so no need for unbind here.
-	
 	}
 
 /***/ },
-/* 49 */
+/* 54 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var applyCSSTransition = __webpack_require__(56)
-	var applyJSTransition = __webpack_require__(57)
-	var doc = typeof document === 'undefined' ? null : document
-	
+	var _ = __webpack_require__(2)
+	var inDoc = _.inDoc
+
 	/**
-	 * Append with transition.
-	 *
-	 * @oaram {Element} el
-	 * @param {Element} target
-	 * @param {Vue} vm
-	 * @param {Function} [cb]
+	 * Setup the instance's option events & watchers.
+	 * If the value is a string, we pull it from the
+	 * instance's methods by name.
 	 */
-	
-	exports.append = function (el, target, vm, cb) {
-	  apply(el, 1, function () {
-	    target.appendChild(el)
-	  }, vm, cb)
+
+	exports._initEvents = function () {
+	  var options = this.$options
+	  registerCallbacks(this, '$on', options.events)
+	  registerCallbacks(this, '$watch', options.watch)
 	}
-	
+
 	/**
-	 * InsertBefore with transition.
+	 * Register callbacks for option events and watchers.
 	 *
-	 * @oaram {Element} el
-	 * @param {Element} target
 	 * @param {Vue} vm
-	 * @param {Function} [cb]
+	 * @param {String} action
+	 * @param {Object} hash
 	 */
-	
-	exports.before = function (el, target, vm, cb) {
-	  apply(el, 1, function () {
-	    _.before(el, target)
-	  }, vm, cb)
+
+	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)
+	    }
+	  }
 	}
-	
+
 	/**
-	 * Remove with transition.
+	 * Helper to register an event/watch callback.
 	 *
-	 * @oaram {Element} el
 	 * @param {Vue} vm
-	 * @param {Function} [cb]
+	 * @param {String} action
+	 * @param {String} key
+	 * @param {*} handler
 	 */
-	
-	exports.remove = function (el, vm, cb) {
-	  apply(el, -1, function () {
-	    _.remove(el)
-	  }, vm, cb)
+
+	function register (vm, action, key, handler) {
+	  var type = typeof handler
+	  if (type === 'function') {
+	    vm[action](key, handler)
+	  } else if (type === 'string') {
+	    var methods = vm.$options.methods
+	    var method = methods && methods[handler]
+	    if (method) {
+	      vm[action](key, method)
+	    } else {
+	      _.warn(
+	        'Unknown method: "' + handler + '" when ' +
+	        'registering callback for ' + action +
+	        ': "' + key + '".'
+	      )
+	    }
+	  }
 	}
-	
+
 	/**
-	 * Remove by appending to another parent with transition.
-	 * This is only used in block operations.
-	 *
-	 * @oaram {Element} el
-	 * @param {Element} target
-	 * @param {Vue} vm
-	 * @param {Function} [cb]
+	 * Setup recursive attached/detached calls
 	 */
-	
-	exports.removeThenAppend = function (el, target, vm, cb) {
-	  apply(el, -1, function () {
-	    target.appendChild(el)
-	  }, vm, cb)
+
+	exports._initDOMHooks = function () {
+	  this.$on('hook:attached', onAttached)
+	  this.$on('hook:detached', onDetached)
 	}
-	
+
 	/**
-	 * Append the childNodes of a fragment to target.
-	 *
-	 * @param {DocumentFragment} block
-	 * @param {Node} target
-	 * @param {Vue} vm
+	 * Callback to recursively call attached hook on children
 	 */
-	
-	exports.blockAppend = function (block, target, vm) {
-	  var nodes = _.toArray(block.childNodes)
-	  for (var i = 0, l = nodes.length; i < l; i++) {
-	    exports.before(nodes[i], target, vm)
+
+	function onAttached () {
+	  this._isAttached = true
+	  this._children.forEach(callAttach)
+	  if (this._transCpnts.length) {
+	    this._transCpnts.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 () {
+	  this._isAttached = false
+	  this._children.forEach(callDetach)
+	  if (this._transCpnts.length) {
+	    this._transCpnts.forEach(callDetach)
 	  }
 	}
-	
+
 	/**
-	 * Remove a block of nodes between two edge nodes.
-	 *
-	 * @param {Node} start
-	 * @param {Node} end
-	 * @param {Vue} vm
+	 * Iterator to call detached hook
+	 * 
+	 * @param {Vue} child
 	 */
-	
-	exports.blockRemove = function (start, end, vm) {
-	  var node = start.nextSibling
-	  var next
-	  while (node !== end) {
-	    next = node.nextSibling
-	    exports.remove(node, vm)
-	    node = next
+
+	function callDetach (child) {
+	  if (child._isAttached && !inDoc(child.$el)) {
+	    child._callHook('detached')
 	  }
 	}
-	
+
 	/**
-	 * Apply transitions with an operation callback.
+	 * Trigger all handlers for a hook
 	 *
-	 * @oaram {Element} el
-	 * @param {Number} direction
-	 *                  1: enter
-	 *                 -1: leave
-	 * @param {Function} op - the actual DOM operation
-	 * @param {Vue} vm
-	 * @param {Function} [cb]
+	 * @param {String} hook
 	 */
-	
-	var apply = exports.apply = function (el, direction, op, vm, cb) {
-	  var transData = el.__v_trans
-	  if (
-	    !transData ||
-	    !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
-	  }
-	  // determine the transition type on the element
-	  var jsTransition = transData.fns
-	  if (jsTransition) {
-	    // js
-	    applyJSTransition(
-	      el,
-	      direction,
-	      op,
-	      transData,
-	      jsTransition,
-	      vm,
-	      cb
-	    )
-	  } else 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.
-	    !(doc && doc.hidden)
-	  ) {
-	    // css
-	    applyCSSTransition(
-	      el,
-	      direction,
-	      op,
-	      transData,
-	      cb
-	    )
-	  } else {
-	    // not applicable
-	    op()
-	    if (cb) cb()
+
+	exports._callHook = function (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)
 	}
 
 /***/ },
-/* 50 */
+/* 55 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var Path = __webpack_require__(18)
-	
+	var _ = __webpack_require__(2)
+	var Observer = __webpack_require__(12)
+	var Dep = __webpack_require__(13)
+
 	/**
-	 * Filter filter for v-repeat
-	 *
-	 * @param {String} searchKey
-	 * @param {String} [delimiter]
-	 * @param {String} dataKey
+	 * Setup the scope of an instance, which contains:
+	 * - observed data
+	 * - computed properties
+	 * - user methods
+	 * - meta properties
 	 */
-	
-	exports.filterBy = function (arr, searchKey, delimiter, dataKey) {
-	  // allow optional `in` delimiter
-	  // because why not
-	  if (delimiter && delimiter !== 'in') {
-	    dataKey = delimiter
+
+	exports._initScope = function () {
+	  this._initData()
+	  this._initComputed()
+	  this._initMethods()
+	  this._initMeta()
+	}
+
+	/**
+	 * Initialize the data. 
+	 */
+
+	exports._initData = function () {
+	  // proxy data on instance
+	  var data = this._data
+	  var i, key
+	  // make sure all props properties are observed
+	  var props = this.$options.props
+	  if (props) {
+	    i = props.length
+	    while (i--) {
+	      key = _.camelize(props[i])
+	      if (!(key in data)) {
+	        data[key] = null
+	      }
+	    }
 	  }
-	  // get the search string
-	  var search =
-	    _.stripQuotes(searchKey) ||
-	    this.$get(searchKey)
-	  if (!search) {
-	    return arr
+	  var keys = Object.keys(data)
+	  i = keys.length
+	  while (i--) {
+	    key = keys[i]
+	    if (!_.isReserved(key)) {
+	      this._proxy(key)
+	    }
 	  }
-	  search = ('' + search).toLowerCase()
-	  // get the optional dataKey
-	  dataKey =
-	    dataKey &&
-	    (_.stripQuotes(dataKey) || this.$get(dataKey))
-	  return arr.filter(function (item) {
-	    return dataKey
-	      ? contains(Path.get(item, dataKey), search)
-	      : contains(item, search)
-	  })
+	  // observe data
+	  Observer.create(data).addVm(this)
 	}
-	
+
 	/**
-	 * Filter filter for v-repeat
+	 * Swap the isntance's $data. Called in $data's setter.
 	 *
-	 * @param {String} sortKey
-	 * @param {String} reverseKey
-	 */
-	
-	exports.orderBy = function (arr, sortKey, reverseKey) {
-	  var key =
-	    _.stripQuotes(sortKey) ||
-	    this.$get(sortKey)
-	  if (!key) {
-	    return arr
+	 * @param {Object} newData
+	 */
+
+	exports._setData = function (newData) {
+	  newData = newData || {}
+	  var oldData = this._data
+	  this._data = newData
+	  var keys, key, i
+	  // copy props
+	  var props = this.$options.props
+	  if (props) {
+	    i = props.length
+	    while (i--) {
+	      key = props[i]
+	      newData.$set(key, oldData[key])
+	    }
 	  }
-	  var order = 1
-	  if (reverseKey) {
-	    if (reverseKey === '-1') {
-	      order = -1
-	    } else if (reverseKey.charCodeAt(0) === 0x21) { // !
-	      reverseKey = reverseKey.slice(1)
-	      order = this.$get(reverseKey) ? 1 : -1
-	    } else {
-	      order = this.$get(reverseKey) ? -1 : 1
+	  // unproxy keys not present in new data
+	  keys = Object.keys(oldData)
+	  i = keys.length
+	  while (i--) {
+	    key = keys[i]
+	    if (!_.isReserved(key) && !(key in newData)) {
+	      this._unproxy(key)
 	    }
 	  }
-	  // sort on a copy to avoid mutating original array
-	  return arr.slice().sort(function (a, b) {
-	    if (key !== '$key' && key !== '$value') {
-	      if (a && '$value' in a) a = a.$value
-	      if (b && '$value' in b) b = b.$value
+	  // proxy keys not already proxied,
+	  // and trigger change for changed values
+	  keys = Object.keys(newData)
+	  i = keys.length
+	  while (i--) {
+	    key = keys[i]
+	    if (!this.hasOwnProperty(key) && !_.isReserved(key)) {
+	      // new property
+	      this._proxy(key)
+	    }
+	  }
+	  oldData.__ob__.removeVm(this)
+	  Observer.create(newData).addVm(this)
+	  this._digest()
+	}
+
+	/**
+	 * Proxy a property, so that
+	 * vm.prop === vm._data.prop
+	 *
+	 * @param {String} key
+	 */
+
+	exports._proxy = function (key) {
+	  // need to store ref to self here
+	  // because these getter/setters might
+	  // be called by child instances!
+	  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
 	    }
-	    a = _.isObject(a) ? Path.get(a, key) : a
-	    b = _.isObject(b) ? Path.get(b, key) : b
-	    return a === b ? 0 : a > b ? order : -order
 	  })
 	}
-	
+
 	/**
-	 * String contain helper
+	 * Unproxy a property.
 	 *
-	 * @param {*} val
-	 * @param {String} search
+	 * @param {String} key
 	 */
-	
-	function contains (val, search) {
-	  if (_.isObject(val)) {
-	    for (var key in val) {
-	      if (contains(val[key], search)) {
-	        return true
+
+	exports._unproxy = function (key) {
+	  delete this[key]
+	}
+
+	/**
+	 * Force update on every watcher in scope.
+	 */
+
+	exports._digest = function () {
+	  var i = this._watchers.length
+	  while (i--) {
+	    this._watchers[i].update()
+	  }
+	  var children = this._children
+	  i = children.length
+	  while (i--) {
+	    var child = children[i]
+	    if (child.$options.inherit) {
+	      child._digest()
+	    }
+	  }
+	}
+
+	/**
+	 * Setup computed properties. They are essentially
+	 * special getter/setters
+	 */
+
+	function noop () {}
+	exports._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 = _.bind(userDef, this)
+	        def.set = noop
+	      } else {
+	        def.get = userDef.get
+	          ? _.bind(userDef.get, this)
+	          : noop
+	        def.set = userDef.set
+	          ? _.bind(userDef.set, this)
+	          : noop
 	      }
+	      Object.defineProperty(this, key, def)
+	    }
+	  }
+	}
+
+	/**
+	 * Setup instance methods. Methods must be bound to the
+	 * instance since they might be called by children
+	 * inheriting them.
+	 */
+
+	exports._initMethods = function () {
+	  var methods = this.$options.methods
+	  if (methods) {
+	    for (var key in methods) {
+	      this[key] = _.bind(methods[key], this)
 	    }
-	  } else if (val != null) {
-	    return val.toString().toLowerCase().indexOf(search) > -1
 	  }
 	}
 
-/***/ },
-/* 51 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Initialize meta information like $index, $key & $value.
+	 */
 
-	var _ = __webpack_require__(11)
-	
-	var handlers = {
-	  _default: __webpack_require__(58),
-	  radio: __webpack_require__(59),
-	  select: __webpack_require__(60),
-	  checkbox: __webpack_require__(61)
-	}
-	
-	module.exports = {
-	
-	  priority: 800,
-	  twoWay: true,
-	  handlers: handlers,
-	
-	  /**
-	   * Possible elements:
-	   *   <select>
-	   *   <textarea>
-	   *   <input type="*">
-	   *     - text
-	   *     - checkbox
-	   *     - radio
-	   *     - number
-	   *     - TODO: more types may be supplied as a plugin
-	   */
-	
-	  bind: function () {
-	    // friendly warning...
-	    var filters = this.filters
-	    if (filters && filters.read && !filters.write) {
-	      _.warn(
-	        'It seems you are using a read-only filter with ' +
-	        'v-model. You might want to use a two-way filter ' +
-	        'to ensure correct behavior.'
-	      )
-	    }
-	    var el = this.el
-	    var tag = el.tagName
-	    var handler
-	    if (tag === 'INPUT') {
-	      handler = handlers[el.type] || handlers._default
-	    } else if (tag === 'SELECT') {
-	      handler = handlers.select
-	    } else if (tag === 'TEXTAREA') {
-	      handler = handlers._default
-	    } else {
-	      _.warn("v-model doesn't support element type: " + tag)
-	      return
+	exports._initMeta = function () {
+	  var metas = this.$options._meta
+	  if (metas) {
+	    for (var key in metas) {
+	      this._defineMeta(key, metas[key])
 	    }
-	    handler.bind.call(this)
-	    this.update = handler.update
-	    this.unbind = handler.unbind
 	  }
-	
 	}
 
-/***/ },
-/* 52 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * A doubly linked list-based Least Recently Used (LRU)
-	 * cache. Will keep most recently used items while
-	 * discarding least recently used items when its limit is
-	 * reached. This is a bare-bone version of
-	 * Rasmus Andersson's js-lru:
-	 *
-	 *   https://github.com/rsms/js-lru
-	 *
-	 * @param {Number} limit
-	 * @constructor
-	 */
-	
-	function Cache (limit) {
-	  this.size = 0
-	  this.limit = limit
-	  this.head = this.tail = undefined
-	  this._keymap = {}
-	}
-	
-	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).
+	 * Define a meta property, e.g $index, $key, $value
+	 * which only exists on the vm instance but not in $data.
 	 *
 	 * @param {String} key
 	 * @param {*} value
-	 * @return {Entry|undefined}
 	 */
-	
-	p.put = function (key, value) {
-	  var entry = {
-	    key:key,
-	    value:value
-	  }
-	  this._keymap[key] = entry
-	  if (this.tail) {
-	    this.tail.newer = entry
-	    entry.older = this.tail
-	  } else {
-	    this.head = entry
-	  }
-	  this.tail = entry
-	  if (this.size === this.limit) {
-	    return this.shift()
-	  } else {
-	    this.size++
-	  }
+
+	exports._defineMeta = function (key, value) {
+	  var dep = new Dep()
+	  Object.defineProperty(this, key, {
+	    enumerable: true,
+	    configurable: true,
+	    get: function metaGetter () {
+	      if (Observer.target) {
+	        Observer.target.addDep(dep)
+	      }
+	      return value
+	    },
+	    set: function metaSetter (val) {
+	      if (val !== value) {
+	        value = val
+	        dep.notify()
+	      }
+	    }
+	  })
 	}
-	
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
 	/**
-	 * Purge the least recently used (oldest) entry from the
-	 * cache. Returns the removed entry or undefined if the
-	 * cache was empty.
+	 * 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 {*}
 	 */
-	
-	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
+
+	exports._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[i]
+	    fn = _.resolveAsset(this.$options, 'filters', filter.name)
+	    _.assertAsset(fn, 'filter', filter.name)
+	    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 entry
+	  return value
 	}
-	
+
 	/**
-	 * Get and register recent use of <key>. Returns the value
-	 * associated with <key> or undefined if not in cache.
+	 * 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} key
-	 * @param {Boolean} returnEntry
-	 * @return {Entry|*}
+	 * @param {String} id
+	 * @param {Function} cb
 	 */
-	
-	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
+
+	exports._resolveComponent = function (id, cb) {
+	  var factory = _.resolveAsset(this.$options, 'components', id)
+	  _.assertAsset(factory, 'component', id)
+	  // async component factory
+	  if (!factory.options) {
+	    if (factory.resolved) {
+	      // cached
+	      cb(factory.resolved)
+	    } else if (factory.requested) {
+	      factory.pendingCallbacks.push(cb)
+	    } else {
+	      factory.requested = true
+	      var cbs = factory.pendingCallbacks = [cb]
+	      factory(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)
+	        }
+	      })
 	    }
-	    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
+	  } else {
+	    // normal component
+	    cb(factory)
 	  }
-	  this.tail = entry
-	  return returnEntry
-	    ? entry
-	    : entry.value
 	}
-	
-	module.exports = Cache
 
 /***/ },
-/* 53 */
+/* 57 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var arrayProto = Array.prototype
-	var arrayMethods = Object.create(arrayProto)
-	
+	var Watcher = __webpack_require__(11)
+	var Path = __webpack_require__(17)
+	var textParser = __webpack_require__(20)
+	var dirParser = __webpack_require__(21)
+	var expParser = __webpack_require__(16)
+	var filterRE = /[^|]\|[^|]/
+
 	/**
-	 * Intercept mutating methods and emit events
+	 * Get the value from an expression on this vm.
+	 *
+	 * @param {String} exp
+	 * @return {*}
 	 */
-	
-	;[
-	  'push',
-	  'pop',
-	  'shift',
-	  'unshift',
-	  'splice',
-	  'sort',
-	  'reverse'
-	]
-	.forEach(function (method) {
-	  // cache original method
-	  var original = arrayProto[method]
-	  _.define(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.notify()
-	    return result
-	  })
-	})
-	
+
+	exports.$get = function (exp) {
+	  var res = expParser.parse(exp)
+	  if (res) {
+	    return res.get.call(this, this)
+	  }
+	}
+
 	/**
-	 * Swap the element at the given index with a new value
-	 * and emits corresponding event.
+	 * Set the value from an expression on this vm.
+	 * The expression must be a valid left-hand
+	 * expression in an assignment.
 	 *
-	 * @param {Number} index
+	 * @param {String} exp
 	 * @param {*} val
-	 * @return {*} - replaced element
 	 */
-	
-	_.define(
-	  arrayProto,
-	  '$set',
-	  function $set (index, val) {
-	    if (index >= this.length) {
-	      this.length = index + 1
-	    }
-	    return this.splice(index, 1, val)[0]
+
+	exports.$set = function (exp, val) {
+	  var res = expParser.parse(exp, true)
+	  if (res && res.set) {
+	    res.set.call(this, this, val)
 	  }
-	)
-	
+	}
+
 	/**
-	 * Convenience method to remove the element at given index.
+	 * Add a property on the VM
 	 *
-	 * @param {Number} index
+	 * @param {String} key
 	 * @param {*} val
 	 */
-	
-	_.define(
-	  arrayProto,
-	  '$remove',
-	  function $remove (index) {
-	    /* istanbul ignore if */
-	    if (!this.length) return
-	    if (typeof index !== 'number') {
-	      index = this.indexOf(index)
-	    }
-	    if (index > -1) {
-	      this.splice(index, 1)
-	    }
-	  }
-	)
-	
-	module.exports = arrayMethods
 
-/***/ },
-/* 54 */
-/***/ function(module, exports, __webpack_require__) {
+	exports.$add = function (key, val) {
+	  this._data.$add(key, val)
+	}
 
-	var _ = __webpack_require__(11)
-	var objProto = Object.prototype
-	
 	/**
-	 * Add a new property to an observed object
-	 * and emits corresponding event
+	 * Delete a property on the VM
 	 *
 	 * @param {String} key
-	 * @param {*} val
-	 * @public
 	 */
-	
-	_.define(
-	  objProto,
-	  '$add',
-	  function $add (key, val) {
-	    if (this.hasOwnProperty(key)) return
-	    var ob = this.__ob__
-	    if (!ob || _.isReserved(key)) {
-	      this[key] = val
-	      return
-	    }
-	    ob.convert(key, val)
-	    if (ob.vms) {
-	      var i = ob.vms.length
-	      while (i--) {
-	        var vm = ob.vms[i]
-	        vm._proxy(key)
-	        vm._digest()
-	      }
-	    } else {
-	      ob.notify()
-	    }
+
+	exports.$delete = function (key) {
+	  this._data.$delete(key)
+	}
+
+	/**
+	 * Watch an expression, trigger callback when its
+	 * value changes.
+	 *
+	 * @param {String} exp
+	 * @param {Function} cb
+	 * @param {Boolean} [deep]
+	 * @param {Boolean} [immediate]
+	 * @return {Function} - unwatchFn
+	 */
+
+	exports.$watch = function (exp, cb, deep, immediate) {
+	  var vm = this
+	  var wrappedCb = function (val, oldVal) {
+	    cb.call(vm, val, oldVal)
 	  }
-	)
-	
+	  var watcher = new Watcher(vm, exp, wrappedCb, {
+	    deep: deep,
+	    user: true
+	  })
+	  if (immediate) {
+	    wrappedCb(watcher.value)
+	  }
+	  return function unwatchFn () {
+	    watcher.teardown()
+	  }
+	}
+
 	/**
-	 * Set a property on an observed object, calling add to
-	 * ensure the property is observed.
+	 * Evaluate a text directive, including filters.
 	 *
-	 * @param {String} key
-	 * @param {*} val
-	 * @public
+	 * @param {String} text
+	 * @return {String}
 	 */
-	
-	_.define(
-	  objProto,
-	  '$set',
-	  function $set (key, val) {
-	    this.$add(key, val)
-	    this[key] = val
+
+	exports.$eval = function (text) {
+	  // check for filters.
+	  if (filterRE.test(text)) {
+	    var dir = dirParser.parse(text)[0]
+	    // 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)
+	    return dir.filters
+	      ? this._applyFilters(val, null, dir.filters)
+	      : val
+	  } else {
+	    // no filter
+	    return this.$get(text)
 	  }
-	)
-	
+	}
+
 	/**
-	 * Deletes a property from an observed object
-	 * and emits corresponding event
+	 * Interpolate a piece of template text.
 	 *
-	 * @param {String} key
-	 * @public
+	 * @param {String} text
+	 * @return {String}
 	 */
-	
-	_.define(
-	  objProto,
-	  '$delete',
-	  function $delete (key) {
-	    if (!this.hasOwnProperty(key)) return
-	    delete this[key]
-	    var ob = this.__ob__
-	    if (!ob || _.isReserved(key)) {
-	      return
-	    }
-	    if (ob.vms) {
-	      var i = ob.vms.length
-	      while (i--) {
-	        var vm = ob.vms[i]
-	        vm._unproxy(key)
-	        vm._digest()
-	      }
-	    } else {
-	      ob.notify()
-	    }
+
+	exports.$interpolate = function (text) {
+	  var tokens = textParser.parse(text)
+	  var vm = this
+	  if (tokens) {
+	    return tokens.length === 1
+	      ? vm.$eval(tokens[0].value)
+	      : 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]
+	 */
+
+	exports.$log = function (path) {
+	  var data = path
+	    ? Path.get(this._data, path)
+	    : this._data
+	  if (data) {
+	    data = JSON.parse(JSON.stringify(data))
+	  }
+	  console.log(data)
+	}
 
 /***/ },
-/* 55 */
+/* 58 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	var MAX_UPDATE_COUNT = 10
-	
-	// 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 waiting = false
-	var flushing = false
-	
+	var _ = __webpack_require__(2)
+	var transition = __webpack_require__(33)
+
 	/**
-	 * Reset the batcher's state.
+	 * 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
 	 */
-	
-	function reset () {
-	  queue = []
-	  userQueue = []
-	  has = {}
-	  waiting = false
-	  flushing = false
+
+	exports.$nextTick = function (fn) {
+	  _.nextTick(fn, this)
+	}
+
+	/**
+	 * Append instance to target
+	 *
+	 * @param {Node} target
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
+	 */
+
+	exports.$appendTo = function (target, cb, withTransition) {
+	  return insert(
+	    this, target, cb, withTransition,
+	    append, transition.append
+	  )
+	}
+
+	/**
+	 * Prepend instance to target
+	 *
+	 * @param {Node} target
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
+	 */
+
+	exports.$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
+	 */
+
+	exports.$before = function (target, cb, withTransition) {
+	  return insert(
+	    this, target, cb, withTransition,
+	    before, transition.before
+	  )
 	}
-	
+
 	/**
-	 * Flush both queues and run the jobs.
+	 * Insert instance after target
+	 *
+	 * @param {Node} target
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
 	 */
-	
-	function flush () {
-	  flushing = true
-	  run(queue)
-	  run(userQueue)
-	  reset()
+
+	exports.$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
 	}
-	
+
 	/**
-	 * Run the jobs in a single queue.
+	 * Remove instance from DOM
 	 *
-	 * @param {Array} queue
+	 * @param {Function} [cb]
+	 * @param {Boolean} [withTransition] - defaults to true
 	 */
-	
-	function run (queue) {
-	  // do not cache length because more jobs might be pushed
-	  // as we run existing jobs
-	  for (var i = 0; i < queue.length; i++) {
-	    queue[i].run()
+
+	exports.$remove = function (cb, withTransition) {
+	  var inDoc = this._isAttached && _.inDoc(this.$el)
+	  // if we are not in document, no need to check
+	  // for transitions
+	  if (!inDoc) withTransition = false
+	  var op
+	  var self = this
+	  var realCb = function () {
+	    if (inDoc) self._callHook('detached')
+	    if (cb) cb()
+	  }
+	  if (
+	    this._isBlock &&
+	    !this._blockFragment.hasChildNodes()
+	  ) {
+	    op = withTransition === false
+	      ? append
+	      : transition.removeThenAppend
+	    blockOp(this, this._blockFragment, op, realCb)
+	  } else {
+	    op = withTransition === false
+	      ? remove
+	      : transition.remove
+	    op(this.$el, this, realCb)
 	  }
+	  return this
 	}
-	
+
 	/**
-	 * Push a job into the job queue.
-	 * Jobs with duplicate IDs will be skipped unless it's
-	 * pushed when the queue is being flushed.
+	 * Shared DOM insertion function.
 	 *
-	 * @param {Object} job
-	 *   properties:
-	 *   - {String|Number} id
-	 *   - {Function}      run
+	 * @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
 	 */
-	
-	exports.push = function (job) {
-	  var id = job.id
-	  if (!id || !has[id] || flushing) {
-	    if (!has[id]) {
-	      has[id] = 1
-	    } else {
-	      has[id]++
-	      // detect possible infinite update loops
-	      if (has[id] > MAX_UPDATE_COUNT) {
-	        _.warn(
-	          'You may have an infinite update loop for the ' +
-	          'watcher with expression: "' + job.expression + '".'
-	        )
-	        return
-	      }
-	    }
-	    // A user watcher callback could trigger another
-	    // directive update during the flushing; at that time
-	    // the directive queue would already have been run, so
-	    // we call that update immediately as it is pushed.
-	    if (flushing && !job.user) {
-	      job.run()
-	      return
-	    }
-	    ;(job.user ? userQueue : queue).push(job)
-	    if (!waiting) {
-	      waiting = true
-	      _.nextTick(flush)
-	    }
+
+	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._isBlock) {
+	    blockOp(vm, target, op, cb)
+	  } else {
+	    op(vm.$el, target, vm, cb)
+	  }
+	  if (shouldCallHook) {
+	    vm._callHook('attached')
 	  }
+	  return vm
 	}
 
-/***/ },
-/* 56 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Execute a transition operation on a block instance,
+	 * iterating through all its block nodes.
+	 *
+	 * @param {Vue} vm
+	 * @param {Node} target
+	 * @param {Function} op
+	 * @param {Function} cb
+	 */
 
-	var _ = __webpack_require__(11)
-	var addClass = _.addClass
-	var removeClass = _.removeClass
-	var transDurationProp = _.transitionProp + 'Duration'
-	var animDurationProp = _.animationProp + 'Duration'
-	
-	var queue = []
-	var queued = false
-	
-	/**
-	 * Push a job into the transition queue, which is to be
-	 * executed on next frame.
-	 *
-	 * @param {Element} el    - target element
-	 * @param {Number} dir    - 1: enter, -1: leave
-	 * @param {Function} op   - the actual dom operation
-	 * @param {String} cls    - the className to remove when the
-	 *                          transition is done.
-	 * @param {Function} [cb] - user supplied callback.
-	 */
-	
-	function push (el, dir, op, cls, cb) {
-	  queue.push({
-	    el  : el,
-	    dir : dir,
-	    cb  : cb,
-	    cls : cls,
-	    op  : op
-	  })
-	  if (!queued) {
-	    queued = true
-	    _.nextTick(flush)
+	function blockOp (vm, target, op, cb) {
+	  var current = vm._blockStart
+	  var end = vm._blockEnd
+	  var next
+	  while (next !== end) {
+	    next = current.nextSibling
+	    op(current, target, vm)
+	    current = next
 	  }
+	  op(end, target, vm, cb)
 	}
-	
+
 	/**
-	 * Flush the queue, and do one forced reflow before
-	 * triggering transitions.
+	 * Check for selectors
+	 *
+	 * @param {String|Element} el
 	 */
-	
-	function flush () {
-	  /* jshint unused: false */
-	  var f = document.documentElement.offsetHeight
-	  queue.forEach(run)
-	  queue = []
-	  queued = false
+
+	function query (el) {
+	  return typeof el === 'string'
+	    ? document.querySelector(el)
+	    : el
 	}
-	
+
 	/**
-	 * Run a transition job.
+	 * Append operation that takes a callback.
 	 *
-	 * @param {Object} job
+	 * @param {Node} el
+	 * @param {Node} target
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
 	 */
-	
-	function run (job) {
-	
-	  var el = job.el
-	  var data = el.__v_trans
-	  var cls = job.cls
-	  var cb = job.cb
-	  var op = job.op
-	  var transitionType = getTransitionType(el, data, cls)
-	
-	  if (job.dir > 0) { // ENTER
-	    if (transitionType === 1) {
-	      // trigger transition by removing enter class
-	      removeClass(el, cls)
-	      // only need to listen for transitionend if there's
-	      // a user callback
-	      if (cb) setupTransitionCb(_.transitionEndEvent)
-	    } else if (transitionType === 2) {
-	      // animations are triggered when class is added
-	      // so we just listen for animationend to remove it.
-	      setupTransitionCb(_.animationEndEvent, function () {
-	        removeClass(el, cls)
-	      })
-	    } else {
-	      // no transition applicable
-	      removeClass(el, cls)
-	      if (cb) cb()
-	    }
-	  } else { // LEAVE
-	    if (transitionType) {
-	      // leave transitions/animations are both triggered
-	      // by adding the class, just remove it on end event.
-	      var event = transitionType === 1
-	        ? _.transitionEndEvent
-	        : _.animationEndEvent
-	      setupTransitionCb(event, function () {
-	        op()
-	        removeClass(el, cls)
-	      })
-	    } else {
-	      op()
-	      removeClass(el, cls)
-	      if (cb) cb()
-	    }
-	  }
-	
-	  /**
-	   * Set up a transition end callback, store the callback
-	   * on the element's __v_trans data object, so we can
-	   * clean it up if another transition is triggered before
-	   * the callback is fired.
-	   *
-	   * @param {String} event
-	   * @param {Function} [cleanupFn]
-	   */
-	
-	  function setupTransitionCb (event, cleanupFn) {
-	    data.event = event
-	    var onEnd = data.callback = function transitionCb (e) {
-	      if (e.target === el) {
-	        _.off(el, event, onEnd)
-	        data.event = data.callback = null
-	        if (cleanupFn) cleanupFn()
-	        if (cb) cb()
-	      }
-	    }
-	    _.on(el, event, onEnd)
-	  }
+
+	function append (el, target, vm, cb) {
+	  target.appendChild(el)
+	  if (cb) cb()
 	}
-	
+
 	/**
-	 * Get an element's transition type based on the
-	 * calculated styles
+	 * InsertBefore operation that takes a callback.
 	 *
-	 * @param {Element} el
-	 * @param {Object} data
-	 * @param {String} className
-	 * @return {Number}
-	 *         1 - transition
-	 *         2 - animation
+	 * @param {Node} el
+	 * @param {Node} target
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
 	 */
-	
-	function getTransitionType (el, data, className) {
-	  var type = data.cache && data.cache[className]
-	  if (type) return type
-	  var inlineStyles = el.style
-	  var computedStyles = window.getComputedStyle(el)
-	  var transDuration =
-	    inlineStyles[transDurationProp] ||
-	    computedStyles[transDurationProp]
-	  if (transDuration && transDuration !== '0s') {
-	    type = 1
-	  } else {
-	    var animDuration =
-	      inlineStyles[animDurationProp] ||
-	      computedStyles[animDurationProp]
-	    if (animDuration && animDuration !== '0s') {
-	      type = 2
-	    }
-	  }
-	  if (type) {
-	    if (!data.cache) data.cache = {}
-	    data.cache[className] = type
-	  }
-	  return type
+
+	function before (el, target, vm, cb) {
+	  _.before(el, target)
+	  if (cb) cb()
 	}
-	
+
 	/**
-	 * Apply CSS transition to an element.
+	 * Remove operation that takes a callback.
 	 *
-	 * @param {Element} el
-	 * @param {Number} direction - 1: enter, -1: leave
-	 * @param {Function} op - the actual DOM operation
-	 * @param {Object} data - target element's transition data
-	 */
-	
-	module.exports = function (el, direction, op, data, cb) {
-	  var prefix = data.id || 'v'
-	  var enterClass = prefix + '-enter'
-	  var leaveClass = prefix + '-leave'
-	  // clean up potential previous unfinished transition
-	  if (data.callback) {
-	    _.off(el, data.event, data.callback)
-	    removeClass(el, enterClass)
-	    removeClass(el, leaveClass)
-	    data.event = data.callback = null
-	  }
-	  if (direction > 0) { // enter
-	    addClass(el, enterClass)
-	    op()
-	    push(el, direction, null, enterClass, cb)
-	  } else { // leave
-	    addClass(el, leaveClass)
-	    push(el, direction, op, leaveClass, cb)
-	  }
+	 * @param {Node} el
+	 * @param {Vue} vm - unused
+	 * @param {Function} [cb]
+	 */
+
+	function remove (el, vm, cb) {
+	  _.remove(el)
+	  if (cb) cb()
+	}
+
+/***/ },
+/* 59 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
+	/**
+	 * Listen on the given `event` with `fn`.
+	 *
+	 * @param {String} event
+	 * @param {Function} fn
+	 */
+
+	exports.$on = function (event, fn) {
+	  (this._events[event] || (this._events[event] = []))
+	    .push(fn)
+	  modifyListenerCount(this, event, 1)
+	  return this
 	}
 
-/***/ },
-/* 57 */
-/***/ function(module, exports, __webpack_require__) {
-
 	/**
-	 * Apply JavaScript enter/leave functions.
+	 * Adds an `event` listener that will be invoked a single
+	 * time then automatically removed.
 	 *
-	 * @param {Element} el
-	 * @param {Number} direction - 1: enter, -1: leave
-	 * @param {Function} op - the actual DOM operation
-	 * @param {Object} data - target element's transition data
-	 * @param {Object} def - transition definition object
-	 * @param {Vue} vm - the owner vm of the element
-	 * @param {Function} [cb]
+	 * @param {String} event
+	 * @param {Function} fn
 	 */
-	
-	module.exports = function (el, direction, op, data, def, vm, cb) {
-	  // if the element is the root of an instance,
-	  // use that instance as the transition function context
-	  vm = el.__vue__ || vm
-	  if (data.cancel) {
-	    data.cancel()
-	    data.cancel = null
-	  }
-	  if (direction > 0) { // enter
-	    if (def.beforeEnter) {
-	      def.beforeEnter.call(vm, el)
-	    }
-	    op()
-	    if (def.enter) {
-	      data.cancel = def.enter.call(vm, el, function () {
-	        data.cancel = null
-	        if (cb) cb()
-	      })
-	    } else if (cb) {
-	      cb()
-	    }
-	  } else { // leave
-	    if (def.leave) {
-	      data.cancel = def.leave.call(vm, el, function () {
-	        data.cancel = null
-	        op()
-	        if (cb) cb()
-	      })
-	    } else {
-	      op()
-	      if (cb) cb()
-	    }
+
+	exports.$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
 	}
 
-/***/ },
-/* 58 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Remove the given callback for `event` or all
+	 * registered callbacks.
+	 *
+	 * @param {String} event
+	 * @param {Function} fn
+	 */
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    var self = this
-	    var el = this.el
-	
-	    // check params
-	    // - lazy: update model on "change" instead of "input"
-	    var lazy = this._checkParam('lazy') != null
-	    // - number: cast value into number when updating model.
-	    var number = this._checkParam('number') != null
-	    // - debounce: debounce the input listener
-	    var debounce = parseInt(this._checkParam('debounce'), 10)
-	
-	    // handle composition events.
-	    // http://blog.evanyou.me/2014/01/03/composition-event/
-	    var cpLocked = false
-	    this.cpLock = function () {
-	      cpLocked = true
-	    }
-	    this.cpUnlock = function () {
-	      cpLocked = 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.
-	      set()
-	    }
-	    _.on(el,'compositionstart', this.cpLock)
-	    _.on(el,'compositionend', this.cpUnlock)
-	
-	    // shared setter
-	    function set () {
-	      self.set(
-	        number ? _.toNumber(el.value) : el.value,
-	        true
-	      )
-	    }
-	
-	    // if the directive has filters, we need to
-	    // record cursor position and restore it after updating
-	    // the input with the filtered value.
-	    // also force update for type="range" inputs to enable
-	    // "lock in range" (see #506)
-	    var hasReadFilter = this.filters && this.filters.read
-	    this.listener = hasReadFilter || el.type === 'range'
-	      ? function textInputListener () {
-	          if (cpLocked) return
-	          var charsOffset
-	          // some HTML5 input types throw error here
-	          try {
-	            // record how many chars from the end of input
-	            // the cursor was at
-	            charsOffset = el.value.length - el.selectionStart
-	          } catch (e) {}
-	          // Fix IE10/11 infinite update cycle
-	          // https://github.com/yyx990803/vue/issues/592
-	          /* istanbul ignore if */
-	          if (charsOffset < 0) {
-	            return
-	          }
-	          set()
-	          _.nextTick(function () {
-	            // force a value update, because in
-	            // certain cases the write filters output the
-	            // same result for different input values, and
-	            // the Observer set events won't be triggered.
-	            var newVal = self._watcher.value
-	            self.update(newVal)
-	            if (charsOffset != null) {
-	              var cursorPos =
-	                _.toString(newVal).length - charsOffset
-	              el.setSelectionRange(cursorPos, cursorPos)
-	            }
-	          })
-	        }
-	      : function textInputListener () {
-	          if (cpLocked) return
-	          set()
-	        }
-	
-	    if (debounce) {
-	      this.listener = _.debounce(this.listener, debounce)
-	    }
-	    this.event = lazy ? 'change' : 'input'
-	    // 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) {
-	      jQuery(el).on(this.event, this.listener)
-	    } else {
-	      _.on(el, this.event, this.listener)
-	    }
-	
-	    // IE9 doesn't fire input event on backspace/del/cut
-	    if (!lazy && _.isIE9) {
-	      this.onCut = function () {
-	        _.nextTick(self.listener)
-	      }
-	      this.onDel = function (e) {
-	        if (e.keyCode === 46 || e.keyCode === 8) {
-	          self.listener()
+	exports.$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)
 	        }
 	      }
-	      _.on(el, 'cut', this.onCut)
-	      _.on(el, 'keyup', this.onDel)
-	    }
-	
-	    // set initial value if present
-	    if (
-	      el.hasAttribute('value') ||
-	      (el.tagName === 'TEXTAREA' && el.value.trim())
-	    ) {
-	      this._initValue = number
-	        ? _.toNumber(el.value)
-	        : el.value
-	    }
-	  },
-	
-	  update: function (value) {
-	    this.el.value = _.toString(value)
-	  },
-	
-	  unbind: function () {
-	    var el = this.el
-	    if (this.hasjQuery) {
-	      jQuery(el).off(this.event, this.listener)
-	    } else {
-	      _.off(el, this.event, this.listener)
-	    }
-	    _.off(el,'compositionstart', this.cpLock)
-	    _.off(el,'compositionend', this.cpUnlock)
-	    if (this.onCut) {
-	      _.off(el,'cut', this.onCut)
-	      _.off(el,'keyup', this.onDel)
 	    }
+	    this._events = {}
+	    return this
 	  }
-	
-	}
-
-/***/ },
-/* 59 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    var self = this
-	    var el = this.el
-	    this.listener = function () {
-	      self.set(el.value, true)
-	    }
-	    _.on(el, 'change', this.listener)
-	    if (el.checked) {
-	      this._initValue = el.value
-	    }
-	  },
-	
-	  update: function (value) {
-	    /* jshint eqeqeq: false */
-	    this.el.checked = value == this.el.value
-	  },
-	
-	  unbind: function () {
-	    _.off(this.el, 'change', this.listener)
+	  // specific event
+	  cbs = this._events[event]
+	  if (!cbs) {
+	    return this
 	  }
-	
-	}
-
-/***/ },
-/* 60 */
-/***/ function(module, exports, __webpack_require__) {
-
-	var _ = __webpack_require__(11)
-	var Watcher = __webpack_require__(25)
-	var dirParser = __webpack_require__(21)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    var self = this
-	    var el = this.el
-	    // check options param
-	    var optionsParam = this._checkParam('options')
-	    if (optionsParam) {
-	      initOptions.call(this, optionsParam)
-	    }
-	    this.number = this._checkParam('number') != null
-	    this.multiple = el.hasAttribute('multiple')
-	    this.listener = function () {
-	      var value = self.multiple
-	        ? getMultiValue(el)
-	        : el.value
-	      value = self.number
-	        ? _.isArray(value)
-	          ? value.map(_.toNumber)
-	          : _.toNumber(value)
-	        : value
-	      self.set(value, true)
-	    }
-	    _.on(el, 'change', this.listener)
-	    checkInitialValue.call(this)
-	  },
-	
-	  update: function (value) {
-	    /* jshint eqeqeq: false */
-	    var el = this.el
-	    el.selectedIndex = -1
-	    var multi = this.multiple && _.isArray(value)
-	    var options = el.options
-	    var i = options.length
-	    var option
-	    while (i--) {
-	      option = options[i]
-	      option.selected = multi
-	        ? indexOf(value, option.value) > -1
-	        : value == option.value
-	    }
-	  },
-	
-	  unbind: function () {
-	    _.off(this.el, 'change', this.listener)
-	    if (this.optionWatcher) {
-	      this.optionWatcher.teardown()
+	  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
 	}
-	
+
 	/**
-	 * Initialize the option list from the param.
+	 * Trigger an event on self.
 	 *
-	 * @param {String} expression
+	 * @param {String} event
 	 */
-	
-	function initOptions (expression) {
-	  var self = this
-	  var descriptor = dirParser.parse(expression)[0]
-	  function optionUpdateWatcher (value) {
-	    if (_.isArray(value)) {
-	      self.el.innerHTML = ''
-	      buildOptions(self.el, value)
-	      if (self._watcher) {
-	        self.update(self._watcher.value)
+
+	exports.$emit = function (event) {
+	  this._eventCancelled = false
+	  var cbs = this._events[event]
+	  if (cbs) {
+	    // avoid leaking arguments:
+	    // http://jsperf.com/closure-with-arguments
+	    var i = arguments.length - 1
+	    var args = new Array(i)
+	    while (i--) {
+	      args[i] = arguments[i + 1]
+	    }
+	    i = 0
+	    cbs = cbs.length > 1
+	      ? _.toArray(cbs)
+	      : cbs
+	    for (var l = cbs.length; i < l; i++) {
+	      if (cbs[i].apply(this, args) === false) {
+	        this._eventCancelled = true
 	      }
-	    } else {
-	      _.warn('Invalid options value for v-model: ' + value)
 	    }
 	  }
-	  this.optionWatcher = new Watcher(
-	    this.vm,
-	    descriptor.expression,
-	    optionUpdateWatcher,
-	    {
-	      deep: true,
-	      filters: _.resolveFilters(this.vm, descriptor.filters)
-	    }
-	  )
-	  // update with initial value
-	  optionUpdateWatcher(this.optionWatcher.value)
+	  return this
 	}
-	
+
 	/**
-	 * Build up option elements. IE9 doesn't create options
-	 * when setting innerHTML on <select> elements, so we have
-	 * to use DOM API here.
+	 * Recursively broadcast an event to all children instances.
 	 *
-	 * @param {Element} parent - a <select> or an <optgroup>
-	 * @param {Array} options
+	 * @param {String} event
+	 * @param {...*} additional arguments
 	 */
-	
-	function buildOptions (parent, options) {
-	  var op, el
-	  for (var i = 0, l = options.length; i < l; i++) {
-	    op = options[i]
-	    if (!op.options) {
-	      el = document.createElement('option')
-	      if (typeof op === 'string') {
-	        el.text = el.value = op
-	      } else {
-	        el.text = op.text
-	        el.value = op.value
-	      }
-	    } else {
-	      el = document.createElement('optgroup')
-	      el.label = op.label
-	      buildOptions(el, op.options)
+
+	exports.$broadcast = function (event) {
+	  // if no child has registered for this event,
+	  // then there's no need to broadcast.
+	  if (!this._eventsCount[event]) return
+	  var children = this._children
+	  for (var i = 0, l = children.length; i < l; i++) {
+	    var child = children[i]
+	    child.$emit.apply(child, arguments)
+	    if (!child._eventCancelled) {
+	      child.$broadcast.apply(child, arguments)
 	    }
-	    parent.appendChild(el)
 	  }
+	  return this
 	}
-	
+
 	/**
-	 * Check the initial value for selected options.
+	 * Recursively propagate an event up the parent chain.
+	 *
+	 * @param {String} event
+	 * @param {...*} additional arguments
 	 */
-	
-	function checkInitialValue () {
-	  var initValue
-	  var options = this.el.options
-	  for (var i = 0, l = options.length; i < l; i++) {
-	    if (options[i].hasAttribute('selected')) {
-	      if (this.multiple) {
-	        (initValue || (initValue = []))
-	          .push(options[i].value)
-	      } else {
-	        initValue = options[i].value
-	      }
-	    }
-	  }
-	  if (typeof initValue !== 'undefined') {
-	    this._initValue = this.number
-	      ? _.toNumber(initValue)
-	      : initValue
+
+	exports.$dispatch = function () {
+	  var parent = this.$parent
+	  while (parent) {
+	    parent.$emit.apply(parent, arguments)
+	    parent = parent._eventCancelled
+	      ? null
+	      : parent.$parent
 	  }
+	  return this
 	}
-	
+
 	/**
-	 * Helper to extract a value array for select[multiple]
+	 * Modify the listener counts on all parents.
+	 * This bookkeeping allows $broadcast to return early when
+	 * no child has listened to a certain event.
 	 *
-	 * @param {SelectElement} el
-	 * @return {Array}
+	 * @param {Vue} vm
+	 * @param {String} event
+	 * @param {Number} count
 	 */
-	
-	function getMultiValue (el) {
-	  return Array.prototype.filter
-	    .call(el.options, filterSelected)
-	    .map(getOptionValue)
-	}
-	
-	function filterSelected (op) {
-	  return op.selected
-	}
-	
-	function getOptionValue (op) {
-	  return op.value || op.text
+
+	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
+	  }
 	}
-	
+
+/***/ },
+/* 60 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var _ = __webpack_require__(2)
+
 	/**
-	 * Native Array.indexOf uses strict equal, but in this
-	 * case we need to match string/numbers with soft equal.
+	 * Create a child instance that prototypally inehrits
+	 * data on parent. To achieve that we create an intermediate
+	 * constructor with its prototype pointing to parent.
 	 *
-	 * @param {Array} arr
-	 * @param {*} val
+	 * @param {Object} opts
+	 * @param {Function} [BaseCtor]
+	 * @return {Vue}
+	 * @public
 	 */
-	
-	function indexOf (arr, val) {
-	  /* jshint eqeqeq: false */
-	  var i = arr.length
-	  while (i--) {
-	    if (arr[i] == val) return i
+
+	exports.$addChild = function (opts, BaseCtor) {
+	  BaseCtor = BaseCtor || _.Vue
+	  opts = opts || {}
+	  var parent = this
+	  var ChildVue
+	  var inherit = opts.inherit !== undefined
+	    ? opts.inherit
+	    : BaseCtor.options.inherit
+	  if (inherit) {
+	    var ctors = parent._childCtors
+	    ChildVue = ctors[BaseCtor.cid]
+	    if (!ChildVue) {
+	      var optionName = BaseCtor.options.name
+	      var className = optionName
+	        ? _.classify(optionName)
+	        : 'VueComponent'
+	      ChildVue = new Function(
+	        'return function ' + className + ' (options) {' +
+	        'this.constructor = ' + className + ';' +
+	        'this._init(options) }'
+	      )()
+	      ChildVue.options = BaseCtor.options
+	      ChildVue.prototype = this
+	      ctors[BaseCtor.cid] = ChildVue
+	    }
+	  } else {
+	    ChildVue = BaseCtor
 	  }
-	  return -1
+	  opts._parent = parent
+	  opts._root = parent.$root
+	  var child = new ChildVue(opts)
+	  return child
 	}
 
 /***/ },
 /* 61 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var _ = __webpack_require__(11)
-	
-	module.exports = {
-	
-	  bind: function () {
-	    var self = this
-	    var el = this.el
-	    this.listener = function () {
-	      self.set(el.checked, true)
-	    }
-	    _.on(el, 'change', this.listener)
-	    if (el.checked) {
-	      this._initValue = el.checked
+	var _ = __webpack_require__(2)
+	var compile = __webpack_require__(22)
+
+	/**
+	 * 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
+	 */
+
+	exports.$mount = function (el) {
+	  if (this._isCompiled) {
+	    _.warn('$mount() should be called only once.')
+	    return
+	  }
+	  if (!el) {
+	    el = document.createElement('div')
+	  } else if (typeof el === 'string') {
+	    var selector = el
+	    el = document.querySelector(el)
+	    if (!el) {
+	      _.warn('Cannot find element: ' + selector)
+	      return
 	    }
-	  },
-	
-	  update: function (value) {
-	    this.el.checked = !!value
-	  },
-	
-	  unbind: function () {
-	    _.off(this.el, 'change', this.listener)
 	  }
-	
+	  this._compile(el)
+	  this._isCompiled = true
+	  this._callHook('compiled')
+	  if (_.inDoc(this.$el)) {
+	    this._callHook('attached')
+	    this._initDOMHooks()
+	    ready.call(this)
+	  } else {
+	    this._initDOMHooks()
+	    this.$once('hook:attached', ready)
+	  }
+	  return this
 	}
 
-/***/ },
-/* 62 */
-/***/ function(module, exports, __webpack_require__) {
+	/**
+	 * Mark an instance as ready.
+	 */
 
-	var _ = __webpack_require__(11)
-	
-	exports._resolveComponent = function (id, cb) {
-	  var registry = this.$options.components
-	  var raw = registry[id]
-	  _.assertAsset(raw, 'component', id)
-	  // async component factory
-	  if (!raw.options) {
-	    raw(function resolve (res) {
-	      if (_.isPlainObject(res)) {
-	        res = _.Vue.extend(res)
-	      }
-	      registry[id] = res
-	      cb(res)
-	    })
-	  } else {
-	    cb(raw)
-	  }
+	function ready () {
+	  this._isAttached = true
+	  this._isReady = true
+	  this._callHook('ready')
+	}
+
+	/**
+	 * Teardown the instance, simply delegate to the internal
+	 * _destroy.
+	 */
+
+	exports.$destroy = function (remove, deferCleanup) {
+	  this._destroy(remove, deferCleanup)
+	}
+
+	/**
+	 * Partially compile a piece of DOM and return a
+	 * decompile function.
+	 *
+	 * @param {Element|DocumentFragment} el
+	 * @return {Function}
+	 */
+
+	exports.$compile = function (el) {
+	  return compile(el, this.$options, true)(this, el)
 	}
 
 /***/ }
 /******/ ])
 });
-;
-//# sourceMappingURL=vue.js.map
\ No newline at end of file
+;
\ No newline at end of file
diff --git a/dist/vue.min.js b/dist/vue.min.js
index 986b502b976..14039105422 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -1,7 +1,8 @@
 /**
- * Vue.js v0.11.10
+ * Vue.js v0.12.0-rc
  * (c) 2015 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):"object"==typeof exports?exports.Vue=e():t.Vue=e()}(this,function(){return function(t){function e(i){if(n[i])return n[i].exports;var r=n[i]={exports:{},id:i,loaded:!1};return t[i].call(r.exports,r,r.exports,e),r.loaded=!0,r.exports}var n={};return e.m=t,e.c=n,e.p="",e(0)}([function(t,e,n){function i(t){this._init(t)}var r=n(12),s=r.extend;s(i,n(1)),i.options={directives:n(13),filters:n(14),partials:{},transitions:{},components:{}};var o=i.prototype;Object.defineProperty(o,"$data",{get:function(){return this._data},set:function(t){this._setData(t)}}),s(o,n(2)),s(o,n(3)),s(o,n(4)),s(o,n(5)),s(o,n(6)),s(o,n(7)),s(o,n(8)),s(o,n(9)),s(o,n(10)),s(o,n(11)),t.exports=r.Vue=i},function(t,e,n){function i(t){return new Function("return function "+s.classify(t)+" (options) { this._init(options) }")()}function r(t){c.forEach(function(e){t[e]=function(t,n){return n?void(this.options[e+"s"][t]=n):this.options[e+"s"][t]}}),t.component=function(t,e){return e?(s.isPlainObject(e)&&(e.name=t,e=s.Vue.extend(e)),void(this.options.components[t]=e)):this.options.components[t]}}var s=n(12),o=n(15);e.util=s,e.nextTick=s.nextTick,e.config=n(16),e.compiler={compile:n(17),transclude:n(18)},e.parsers={path:n(19),text:n(20),template:n(21),directive:n(22),expression:n(23)},e.cid=0;var a=1;e.extend=function(t){t=t||{};var e=this,n=i(t.name||e.options.name||"VueComponent");return n.prototype=Object.create(e.prototype),n.prototype.constructor=n,n.cid=a++,n.options=o(e.options,t),n["super"]=e,n.extend=e.extend,r(n),n},e.use=function(t){var e=s.toArray(arguments,1);return e.unshift(this),"function"==typeof t.install?t.install.apply(t,e):t.apply(null,e),this};var c=["directive","filter","partial","transition"];r(e)},function(t,e,n){var i=n(15);e._init=function(t){t=t||{},this.$el=null,this.$parent=t._parent,this.$root=t._root||this,this.$={},this.$$={},this._watcherList=[],this._watchers={},this._userWatchers={},this._directives=[],this._isVue=!0,this._events={},this._eventsCount={},this._eventCancelled=!1,this._isBlock=!1,this._blockStart=this._blockEnd=null,this._isCompiled=this._isDestroyed=this._isReady=this._isAttached=this._isBeingDestroyed=!1,this._unlinkFn=null,this._children=[],this._childCtors={},this._transCpnts=[],this._host=t._host,this.$parent&&this.$parent._children.push(this),this._host&&this._host._transCpnts.push(this),this._new=!0,this._reused=!1,t=this.$options=i(this.constructor.options,t,this),this._data=t.data||{},this._initScope(),this._initEvents(),this._callHook("created"),t.el&&this.$mount(t.el)}},function(t,e,n){function i(t,e,n){if(n){var i,s,o,a;for(s in n)if(i=n[s],h.isArray(i))for(o=0,a=i.length;a>o;o++)r(t,e,s,i[o]);else r(t,e,s,i)}}function r(t,e,n,i){var r=typeof i;if("function"===r)t[e](n,i);else if("string"===r){var s=t.$options.methods,o=s&&s[i];o&&t[e](n,o)}}function s(){this._isAttached=!0,this._children.forEach(o),this._transCpnts.length&&this._transCpnts.forEach(o)}function o(t){!t._isAttached&&u(t.$el)&&t._callHook("attached")}function a(){this._isAttached=!1,this._children.forEach(c),this._transCpnts.length&&this._transCpnts.forEach(c)}function c(t){t._isAttached&&!u(t.$el)&&t._callHook("detached")}var h=n(12),u=h.inDoc;e._initEvents=function(){var t=this.$options;i(this,"$on",t.events),i(this,"$watch",t.watch)},e._initDOMHooks=function(){this.$on("hook:attached",s),this.$on("hook:detached",a)},e._callHook=function(t){var e=this.$options[t];if(e)for(var n=0,i=e.length;i>n;n++)e[n].call(this);this.$emit("hook:"+t)}},function(t,e,n){function i(){}var r=n(12),s=n(50),o=n(25);e._initScope=function(){this._initData(),this._initComputed(),this._initMethods(),this._initMeta()},e._initData=function(){var t,e,n=this._data,i=this.$options.paramAttributes;if(i)for(t=i.length;t--;)e=r.camelize(i[t]),e in n||(n[e]=null);var o=Object.keys(n);for(t=o.length;t--;)e=o[t],r.isReserved(e)||this._proxy(e);s.create(n).addVm(this)},e._setData=function(t){t=t||{};var e=this._data;this._data=t;var n,i,o;for(n=Object.keys(e),o=n.length;o--;)i=n[o],r.isReserved(i)||i in t||this._unproxy(i);for(n=Object.keys(t),o=n.length;o--;)i=n[o],this.hasOwnProperty(i)||r.isReserved(i)||this._proxy(i);e.__ob__.removeVm(this),s.create(t).addVm(this),this._digest()},e._proxy=function(t){var e=this;Object.defineProperty(e,t,{configurable:!0,enumerable:!0,get:function(){return e._data[t]},set:function(n){e._data[t]=n}})},e._unproxy=function(t){delete this[t]},e._digest=function(){for(var t=this._watcherList.length;t--;)this._watcherList[t].update();var e=this._children;for(t=e.length;t--;){var n=e[t];n.$options.inherit&&n._digest()}},e._initComputed=function(){var t=this.$options.computed;if(t)for(var e in t){var n=t[e],s={enumerable:!0,configurable:!0};"function"==typeof n?(s.get=r.bind(n,this),s.set=i):(s.get=n.get?r.bind(n.get,this):i,s.set=n.set?r.bind(n.set,this):i),Object.defineProperty(this,e,s)}},e._initMethods=function(){var t=this.$options.methods;if(t)for(var e in t)this[e]=r.bind(t[e],this)},e._initMeta=function(){var t=this.$options._meta;if(t)for(var e in t)this._defineMeta(e,t[e])},e._defineMeta=function(t,e){var n=new o;Object.defineProperty(this,t,{enumerable:!0,configurable:!0,get:function(){return s.target&&s.target.addDep(n),e},set:function(t){t!==e&&(e=t,n.notify())}})}},function(t,e,n){var i=n(12),r=n(24),s=n(17),o=n(18);e._compile=function(t){var e=this.$options;if(e._linkFn)this._initElement(t),this._unlinkFn=e._linkFn(this,t);else{var n=t;t=o(t,e),this._initElement(t),this._unlinkFn=s(t,e)(this,t),e.replace&&i.replace(n,t)}return t},e._initElement=function(t){t instanceof DocumentFragment?(this._isBlock=!0,this.$el=this._blockStart=t.firstChild,this._blockEnd=t.lastChild,this._blockFragment=t):this.$el=t,this.$el.__vue__=this,this._callHook("beforeCompile")},e._bindDir=function(t,e,n,i,s){this._directives.push(new r(t,e,this,n,i,s))},e._destroy=function(t,e){if(!this._isBeingDestroyed){this._callHook("beforeDestroy"),this._isBeingDestroyed=!0;var n,i=this.$parent;i&&!i._isBeingDestroyed&&i._children.$remove(this);var r=this._host;for(r&&!r._isBeingDestroyed&&r._transCpnts.$remove(this),n=this._children.length;n--;)this._children[n].$destroy();this._unlinkFn&&this._unlinkFn(!0);var s;for(n in this._userWatchers)s=this._userWatchers[n],s&&s.teardown();this.$el&&(this.$el.__vue__=null);var o=this;t&&this.$el?this.$remove(function(){o._cleanup()}):e||this._cleanup()}},e._cleanup=function(){this._data.__ob__.removeVm(this),this._data=this._watchers=this._userWatchers=this._watcherList=this.$el=this.$parent=this.$root=this._children=this._transCpnts=this._directives=null,this._isDestroyed=!0,this._callHook("destroyed"),this.$off()}},function(t,e,n){var i=n(12);e._resolveComponent=function(t,e){var n=this.$options.components,r=n[t];r.options?e(r):r(function(r){i.isPlainObject(r)&&(r=i.Vue.extend(r)),n[t]=r,e(r)})}},function(t,e,n){var i=n(12),r=n(26),s=n(19),o=n(20),a=n(22),c=n(23),h=/[^|]\|[^|]/;e.$get=function(t){var e=c.parse(t);return e?e.get.call(this,this):void 0},e.$set=function(t,e){var n=c.parse(t,!0);n&&n.set&&n.set.call(this,this,e)},e.$add=function(t,e){this._data.$add(t,e)},e.$delete=function(t){this._data.$delete(t)},e.$watch=function(t,e,n,i){var s=this,o=n?t+"**deep**":t,a=s._userWatchers[o],c=function(t,n){e.call(s,t,n)};return a?a.addCb(c):a=s._userWatchers[o]=new r(s,t,c,{deep:n,user:!0}),i&&c(a.value),function(){a.removeCb(c),a.active||(s._userWatchers[o]=null)}},e.$eval=function(t){if(h.test(t)){var e=a.parse(t)[0];return e.filters?i.applyFilters(this.$get(e.expression),i.resolveFilters(this,e.filters).read,this):this.$get(e.expression)}return this.$get(t)},e.$interpolate=function(t){var e=o.parse(t),n=this;return e?1===e.length?n.$eval(e[0].value):e.map(function(t){return t.tag?n.$eval(t.value):t.value}).join(""):t},e.$log=function(t){var e=t?s.get(this._data,t):this._data;e&&(e=JSON.parse(JSON.stringify(e))),console.log(e)}},function(t,e,n){function i(t,e,n,i,o,a){e=s(e);var c=!h.inDoc(e),u=i===!1||c?o:a,l=!c&&!t._isAttached&&!h.inDoc(t.$el);return t._isBlock?r(t,e,u,n):u(t.$el,e,t,n),l&&t._callHook("attached"),t}function r(t,e,n,i){for(var r,s=t._blockStart,o=t._blockEnd;r!==o;)r=s.nextSibling,n(s,e,t),s=r;n(o,e,t,i)}function s(t){return"string"==typeof t?document.querySelector(t):t}function o(t,e,n,i){e.appendChild(t),i&&i()}function a(t,e,n,i){h.before(t,e),i&&i()}function c(t,e,n){h.remove(t),n&&n()}var h=n(12),u=n(51);e.$appendTo=function(t,e,n){return i(this,t,e,n,o,u.append)},e.$prependTo=function(t,e,n){return t=s(t),t.hasChildNodes()?this.$before(t.firstChild,e,n):this.$appendTo(t,e,n),this},e.$before=function(t,e,n){return i(this,t,e,n,a,u.before)},e.$after=function(t,e,n){return t=s(t),t.nextSibling?this.$before(t.nextSibling,e,n):this.$appendTo(t.parentNode,e,n),this},e.$remove=function(t,e){var n=this._isAttached&&h.inDoc(this.$el);n||(e=!1);var i,s=this,a=function(){n&&s._callHook("detached"),t&&t()};return this._isBlock&&!this._blockFragment.hasChildNodes()?(i=e===!1?o:u.removeThenAppend,r(this,this._blockFragment,i,a)):(i=e===!1?c:u.remove)(this.$el,this,a),this}},function(t,e,n){function i(t,e,n){var i=t.$parent;if(i&&n&&!s.test(e))for(;i;)i._eventsCount[e]=(i._eventsCount[e]||0)+n,i=i.$parent}var r=n(12);e.$on=function(t,e){return(this._events[t]||(this._events[t]=[])).push(e),i(this,t,1),this},e.$once=function(t,e){function n(){i.$off(t,n),e.apply(this,arguments)}var i=this;return n.fn=e,this.$on(t,n),this},e.$off=function(t,e){var n;if(!arguments.length){if(this.$parent)for(t in this._events)n=this._events[t],n&&i(this,t,-n.length);return this._events={},this}if(n=this._events[t],!n)return this;if(1===arguments.length)return i(this,t,-n.length),this._events[t]=null,this;for(var r,s=n.length;s--;)if(r=n[s],r===e||r.fn===e){i(this,t,-1),n.splice(s,1);break}return this},e.$emit=function(t){this._eventCancelled=!1;var e=this._events[t];if(e){for(var n=arguments.length-1,i=new Array(n);n--;)i[n]=arguments[n+1];n=0,e=e.length>1?r.toArray(e):e;for(var s=e.length;s>n;n++)e[n].apply(this,i)===!1&&(this._eventCancelled=!0)}return this},e.$broadcast=function(t){if(this._eventsCount[t]){for(var e=this._children,n=0,i=e.length;i>n;n++){var r=e[n];r.$emit.apply(r,arguments),r._eventCancelled||r.$broadcast.apply(r,arguments)}return this}},e.$dispatch=function(){for(var t=this.$parent;t;)t.$emit.apply(t,arguments),t=t._eventCancelled?null:t.$parent;return this};var s=/^hook:/},function(t,e,n){var i=n(12);e.$addChild=function(t,e){e=e||i.Vue,t=t||{};var n,r=this,s=void 0!==t.inherit?t.inherit:e.options.inherit;if(s){var o=r._childCtors;if(n=o[e.cid],!n){var a=e.options.name,c=a?i.classify(a):"VueComponent";n=new Function("return function "+c+" (options) {this.constructor = "+c+";this._init(options) }")(),n.options=e.options,n.prototype=this,o[e.cid]=n}}else n=e;t._parent=r,t._root=r.$root;var h=new n(t);return h}},function(t,e,n){function i(){this._isAttached=!0,this._isReady=!0,this._callHook("ready")}var r=n(12),s=n(17);e.$mount=function(t){if(!this._isCompiled){if(t){if("string"==typeof t){if(t=document.querySelector(t),!t)return}}else t=document.createElement("div");return this._compile(t),this._isCompiled=!0,this._callHook("compiled"),r.inDoc(this.$el)?(this._callHook("attached"),this._initDOMHooks(),i.call(this)):(this._initDOMHooks(),this.$once("hook:attached",i)),this}},e.$destroy=function(t,e){this._destroy(t,e)},e.$compile=function(t){return s(t,this.$options,!0)(this,t)}},function(t,e,n){var i=n(27),r=i.extend;r(e,i),r(e,n(28)),r(e,n(29)),r(e,n(30)),r(e,n(31))},function(t,e,n){e.text=n(32),e.html=n(33),e.attr=n(34),e.show=n(35),e["class"]=n(36),e.el=n(37),e.ref=n(38),e.cloak=n(39),e.style=n(40),e.partial=n(41),e.transition=n(42),e.on=n(43),e.model=n(52),e.component=n(44),e.repeat=n(45),e["if"]=n(46),e["with"]=n(47),e.events=n(48)},function(t,e,n){var i=n(12);e.json={read:function(t,e){return"string"==typeof t?t:JSON.stringify(t,null,Number(e)||2)},write:function(t){try{return JSON.parse(t)}catch(e){return t}}},e.capitalize=function(t){return t||0===t?(t=t.toString(),t.charAt(0).toUpperCase()+t.slice(1)):""},e.uppercase=function(t){return t||0===t?t.toString().toUpperCase():""},e.lowercase=function(t){return t||0===t?t.toString().toLowerCase():""};var r=/(\d{3})(?=\d)/g;e.currency=function(t,e){if(t=parseFloat(t),!isFinite(t)||!t&&0!==t)return"";e=e||"$";var n=Math.floor(Math.abs(t)).toString(),i=n.length%3,s=i>0?n.slice(0,i)+(n.length>3?",":""):"",o=Math.abs(parseInt(100*t%100,10)),a="."+(10>o?"0"+o:o);return(0>t?"-":"")+e+s+n.slice(i).replace(r,"$1,")+a},e.pluralize=function(t){var e=i.toArray(arguments,1);return e.length>1?e[t%10-1]||e[e.length-1]:e[0]+(1===t?"":"s")};var s={enter:13,tab:9,"delete":46,up:38,left:37,right:39,down:40,esc:27};e.key=function(t,e){if(t){var n=s[e];return n||(n=parseInt(e,10)),function(e){return e.keyCode===n?t.call(this,e):void 0}}},e.key.keyCodes=s,i.extend(e,n(49))},function(t,e,n){function i(t,e){var n,r,o;for(n in e)r=t[n],o=e[n],t.hasOwnProperty(n)?s.isObject(r)&&s.isObject(o)&&i(r,o):t.$add(n,o);return t}function r(t){if(t){var e;for(var n in t)e=t[n],s.isPlainObject(e)&&(e.name=n,t[n]=s.Vue.extend(e))}}var s=n(12),o=s.extend,a=Object.create(null);a.data=function(t,e,n){if(n){var r="function"==typeof e?e.call(n):e,s="function"==typeof t?t.call(n):void 0;return r?i(r,s):s}return e?"function"!=typeof e?t:t?function(){return i(e.call(this),t.call(this))}:e:t},a.el=function(t,e,n){if(n||!e||"function"==typeof e){var i=e||t;return n&&"function"==typeof i?i.call(n):i}},a.created=a.ready=a.attached=a.detached=a.beforeCompile=a.compiled=a.beforeDestroy=a.destroyed=a.paramAttributes=function(t,e){return e?t?t.concat(e):s.isArray(e)?e:[e]:t},a.directives=a.filters=a.partials=a.transitions=a.components=function(t,e,n,i){var r=Object.create(n&&n.$parent?n.$parent.$options[i]:s.Vue.options[i]);if(t)for(var a,c=Object.keys(t),h=c.length;h--;)a=c[h],r[a]=t[a];return e&&o(r,e),r},a.watch=a.events=function(t,e){if(!e)return t;if(!t)return e;var n={};o(n,t);for(var i in e){var r=n[i],a=e[i];r&&!s.isArray(r)&&(r=[r]),n[i]=r?r.concat(a):[a]}return n},a.methods=a.computed=function(t,e){if(!e)return t;if(!t)return e;var n=Object.create(t);return o(n,e),n};var c=function(t,e){return void 0===e?t:e};t.exports=function h(t,e,n){function i(i){var r=a[i]||c;o[i]=r(t[i],e[i],n,i)}r(e.components);var s,o={};if(e.mixins)for(var u=0,l=e.mixins.length;l>u;u++)t=h(t,e.mixins[u],n);for(s in t)i(s);for(s in e)t.hasOwnProperty(s)||i(s);return o}},function(t,e,n){t.exports={prefix:"v-",debug:!1,silent:!1,proto:!0,interpolate:!0,async:!0,warnExpressionErrors:!0,_delimitersChanged:!0,_terminalDirectives:["repeat","if","component"]};var i=["{{","}}"];Object.defineProperty(t.exports,"delimiters",{get:function(){return i},set:function(t){i=t,this._delimitersChanged=!0}})},function(t,e,n){function i(t,e,n,i){function a(t,e){var n=t._directives.length,s=t.$parent&&t.$parent._directives.length,o=k.toArray(e.childNodes),a=i?t.$parent:t,u=i?t:void 0;c&&c(a,e,u),h&&h(a,o,u);var l=t._directives.slice(n),f=t.$parent&&t.$parent._directives.slice(s);return function(e){r(t,l,e),f&&r(t.$parent,f)}}var c=e._asComponent&&!n?s(t,e):o(t,e),h=c&&c.terminal||"SCRIPT"===t.tagName||!t.hasChildNodes()?null:l(t.childNodes,e);return i&&(a.terminal=!0),a}function r(t,e,n){for(var i=e.length;i--;)e[i]._teardown(),n||t._directives.$remove(e[i])}function s(t,e){var n,i,r,s,o=11===t.nodeType,a=e._containerAttrs,c=e._replacerAttrs,h=e.paramAttributes;n=h?d(t,a,h,e):null;var u=C.prefix+"with",l=a&&a[u];return l&&(a[u]=null,i=y([{name:"with",descriptors:E.parse(l),def:e.directives["with"]}])),o||(a&&(r=b(a,e)),c&&(s=b(c,e))),function(t,e,o){n&&n(t,null),i&&i(t,null),r&&r(t.$parent,e,o),s&&s(t,e,o)}}function o(t,e){var n=t.nodeType;return 1===n&&"SCRIPT"!==t.tagName?a(t,e):3===n&&C.interpolate&&t.data.trim()?c(t,e):null}function a(t,e){if(x(t))return t.hasAttribute("__vue__wrap")&&(t=t.firstChild),i(t,e._parent.$options,!0,!0);var n,r,s;if(t.__vue__||(r=t.tagName.toLowerCase(),s=r.indexOf("-")>0&&e.components[r],s&&t.setAttribute(C.prefix+"component",r)),(s||t.hasAttributes())&&(n=v(t,e),n||(n=b(t,e))),"TEXTAREA"===t.tagName){var o=n;n=function(t,e){e.value=t.$interpolate(e.value),o&&o(t,e)},n.terminal=!0}return n}function c(t,e){var n=A.parse(t.data);if(!n)return null;for(var i,r,s=document.createDocumentFragment(),o=0,a=n.length;a>o;o++)r=n[o],i=r.tag?h(r,e):document.createTextNode(r.value),s.appendChild(i);return u(n,s,e)}function h(t,e){function n(n){t.type=n,t.def=e.directives[n],t.descriptor=E.parse(t.value)[0]}var i;return t.oneTime?i=document.createTextNode(t.value):t.html?(i=document.createComment("v-html"),n("html")):t.partial?(i=document.createComment("v-partial"),n("partial")):(i=document.createTextNode(" "),n("text")),i}function u(t,e){return function(n,i){for(var r,s,o,a=e.cloneNode(!0),c=k.toArray(a.childNodes),h=0,u=t.length;u>h;h++)r=t[h],s=r.value,r.tag&&(o=c[h],r.oneTime?(s=n.$eval(s),r.html?k.replace(o,T.parse(s,!0)):o.data=s):n._bindDir(r.type,o,r.descriptor,r.def));k.replace(i,a)}}function l(t,e){for(var n,i,r,s=[],a=0,c=t.length;c>a;a++)r=t[a],n=o(r,e),i=n&&n.terminal||"SCRIPT"===r.tagName||!r.hasChildNodes()?null:l(r.childNodes,e),s.push(n,i);return s.length?f(s):null}function f(t){return function(e,n,i){for(var r,s,o,a=0,c=0,h=t.length;h>a;c++){r=n[c],s=t[a++],o=t[a++];var u=k.toArray(r.childNodes);s&&s(e,r,i),o&&o(e,u,i)}}}function d(t,e,n,i){for(var r,s,o,a=[],c=n.length;c--;)if(r=n[c],/[A-Z]/.test(r),s=e[r],null!==s){o={name:r,value:s};var h=A.parse(s);if(h){if(t&&1===t.nodeType&&t.removeAttribute(r),e[r]=null,h.length>1)continue;o.dynamic=!0,o.value=h[0].value}a.push(o)}return p(a,i)}function p(t,e){var n=e.directives["with"];return function(e,i){for(var r,s,o=t.length;o--;)r=t[o],s=k.camelize(r.name.replace(D,"")),r.dynamic?e._bindDir("with",i,{arg:s,expression:r.value},n):e.$set(s,r.value)}}function v(t,e){if(null!==k.attr(t,"pre"))return m;for(var n,i,r=C._terminalDirectives,s=0,o=r.length;o>s;s++)if(i=r[s],null!==(n=k.attr(t,i)))return _(t,i,n,e)}function m(){}function _(t,e,n,i){var r=E.parse(n)[0],s=i.directives[e],o=function(t,n,i){t._bindDir(e,n,r,s,i)};return o.terminal=!0,o}function b(t,e){for(var n,i,r,s,o,a,c=k.isPlainObject(t)?g(t):t.attributes,h=c.length,u=[];h--;)n=c[h],i=n.name,r=n.value,null!==r&&(0===i.indexOf(C.prefix)?(o=i.slice(C.prefix.length),a=e.directives[o],a&&u.push({name:o,descriptors:E.parse(r),def:a})):C.interpolate&&(s=$(i,r,e),s&&u.push(s)));return u.length?(u.sort(w),y(u)):void 0}function g(t){var e=[];for(var n in t)e.push({name:n,value:t[n]});return e}function y(t){return function(e,n,i){for(var r,s,o,a=t.length;a--;)if(r=t[a],r._link)r._link(e,n);else for(o=r.descriptors.length,s=0;o>s;s++)e._bindDir(r.name,n,r.descriptors[s],r.def,i)}}function $(t,e,n){var i=A.parse(e);if(i){for(var r=n.directives.attr,s=i.length,o=!0;s--;){var a=i[s];a.tag&&!a.oneTime&&(o=!1)}return{def:r,_link:o?function(n,i){i.setAttribute(t,n.$interpolate(e))}:function(e,n){var s=A.tokensToExp(i,e),o=E.parse(t+":"+s)[0];e._bindDir("attr",n,o,r)}}}}function w(t,e){return t=t.def.priority||0,e=e.def.priority||0,t>e?1:-1}function x(t){return 1===t.nodeType&&t.hasAttribute(N)?(t.removeAttribute(N),!0):void 0}var k=n(12),C=n(16),A=n(20),E=n(22),T=n(21);t.exports=i;var D=/^data-/;m.terminal=!0;var N="__vue__transcluded"},function(t,e,n){function i(t,e){var n=e.template,i=u.parse(n,!0);if(i){var s=e._content||h.extractContent(t);if(e.replace){if(i.childNodes.length>1)return r(i,s),i;var o=i.firstChild;return e._replacerAttrs=a(o),c(t,o),r(o,s),o}return t.appendChild(i),r(t,s),t}}function r(t,e){function n(t){return t.parentNode===e}var i=s(t),r=i.length;if(r){for(var a,c,u,l,f;r--;)a=i[r],e?(c=a.getAttribute("select"),c?(u=e.querySelectorAll(c),u.length&&(u=[].filter.call(u,n)),a.content=u.length?u:h.toArray(a.childNodes)):f=a):a.content=h.toArray(a.childNodes);for(r=0,l=i.length;l>r;r++)a=i[r],a!==f&&o(a,a.content);f&&o(f,h.toArray(e.childNodes))}}function s(t){return h.isArray(t)?f.apply([],t.map(s)):t.querySelectorAll?h.toArray(t.querySelectorAll("content")):[]}function o(t,e){for(var n=t.parentNode,i=0,r=e.length;r>i;i++)n.insertBefore(e[i],t);n.removeChild(t)}function a(t){var e=t.attributes;if(e){for(var n={},i=e.length;i--;)n[e[i].name]=e[i].value;return n}}function c(t,e){for(var n,i,r=t.attributes,s=r.length;s--;)n=r[s].name,i=r[s].value,e.hasAttribute(n)?"class"===n&&(e.className=e.className+" "+i):e.setAttribute(n,i)}var h=n(12),u=n(21),l="__vue__transcluded";t.exports=function(t,e){if(e&&e._asComponent){e._containerAttrs=a(t);for(var n=t.childNodes.length;n--;){var r=t.childNodes[n];if(1===r.nodeType)r.setAttribute(l,"");else if(3===r.nodeType&&r.data.trim()){var s=document.createElement("span");s.textContent=r.data,s.setAttribute("__vue__wrap",""),s.setAttribute(l,""),t.replaceChild(s,r)}}}return"TEMPLATE"===t.tagName&&(t=u.parse(t)),e&&e.template&&(t=i(t,e)),t instanceof DocumentFragment&&(h.prepend(document.createComment("v-start"),t),t.appendChild(document.createComment("v-end"))),t};var f=[].concat},function(t,e,n){function i(){}function r(t){if(void 0===t)return"eof";var e=t.charCodeAt(0);switch(e){case 91:case 93:case 46:case 34:case 39:case 48:return t;case 95:case 36:return"ident";case 32:case 9:case 10:case 13:case 160:case 65279:case 8232:case 8233:return"ws"}return e>=97&&122>=e||e>=65&&90>=e?"ident":e>=49&&57>=e?"number":"else"}function s(t){function e(){var e=t[d+1];return"inSingleQuote"===p&&"'"===e||"inDoubleQuote"===p&&'"'===e?(d++,s=e,v.append(),!0):void 0}for(var n,s,o,a,c,h,u,f=[],d=-1,p="beforePath",v={push:function(){void 0!==o&&(f.push(o),o=void 0)},append:function(){void 0===o?o=s:o+=s}};p;)if(d++,n=t[d],"\\"!==n||!e()){if(a=r(n),u=l[p],c=u[a]||u["else"]||"error","error"===c)return;if(p=c[0],h=v[c[1]]||i,s=void 0===c[2]?n:c[2],h(),"afterPath"===p)return f}}function o(t){return u.test(t)?"."+t:+t===t>>>0?"["+t+"]":'["'+t.replace(/"/g,'\\"')+'"]'}var a=n(12),c=n(53),h=new c(1e3),u=/^[$_a-zA-Z]+[\w$]*$/,l={beforePath:{ws:["beforePath"],ident:["inIdent","append"],"[":["beforeElement"],eof:["afterPath"]},inPath:{ws:["inPath"],".":["beforeIdent"],"[":["beforeElement"],eof:["afterPath"]},beforeIdent:{ws:["beforeIdent"],ident:["inIdent","append"]},inIdent:{ident:["inIdent","append"],0:["inIdent","append"],number:["inIdent","append"],ws:["inPath","push"],".":["beforeIdent","push"],"[":["beforeElement","push"],eof:["afterPath","push"]},beforeElement:{ws:["beforeElement"],0:["afterZero","append"],number:["inIndex","append"],"'":["inSingleQuote","append",""],'"':["inDoubleQuote","append",""]},afterZero:{ws:["afterElement","push"],"]":["inPath","push"]},inIndex:{0:["inIndex","append"],number:["inIndex","append"],ws:["afterElement"],"]":["inPath","push"]},inSingleQuote:{"'":["afterElement"],eof:"error","else":["inSingleQuote","append"]},inDoubleQuote:{'"':["afterElement"],eof:"error","else":["inDoubleQuote","append"]},afterElement:{ws:["afterElement"],"]":["inPath","push"]}};e.compileGetter=function(t){var e="return o"+t.map(o).join("");return new Function("o","try {"+e+"} catch (e) {}")},e.parse=function(t){var n=h.get(t);return n||(n=s(t),n&&(n.get=e.compileGetter(n),h.put(t,n))),n},e.get=function(t,n){return n=e.parse(n),n?n.get(t):void 0},e.set=function(t,n,i){if("string"==typeof n&&(n=e.parse(n)),!n||!a.isObject(t))return!1;for(var r,s,o=0,c=n.length-1;c>o;o++)r=t,s=n[o],t=t[s],a.isObject(t)||(t={},r.$add(s,t));return s=n[o],s in t?t[s]=i:t.$add(s,i),!0}},function(t,e,n){function i(t){return t.replace(v,"\\$&")}function r(){d._delimitersChanged=!1;var t=d.delimiters[0],e=d.delimiters[1];u=t.charAt(0),l=e.charAt(e.length-1);var n=i(u),r=i(l),s=i(t),o=i(e);c=new RegExp(n+"?"+s+"(.+?)"+o+r+"?","g"),h=new RegExp("^"+n+s+".*"+o+r+"$"),a=new f(1e3)}function s(t,e,n){return t.tag?e&&t.oneTime?'"'+e.$eval(t.value)+'"':n?t.value:o(t.value):'"'+t.value+'"'}function o(t){if(m.test(t)){var e=p.parse(t)[0];if(e.filters){t=e.expression;for(var n=0,i=e.filters.length;i>n;n++){var r=e.filters[n],s=r.args?',"'+r.args.join('","')+'"':"";r='this.$options.filters["'+r.name+'"]',t="("+r+".read||"+r+").apply(this,["+t+s+"])"}return t}return"("+t+")"}return"("+t+")"}var a,c,h,u,l,f=n(53),d=n(16),p=n(22),v=/[-.*+?^${}()|[\]\/\\]/g;e.parse=function(t){d._delimitersChanged&&r();var e=a.get(t);if(e)return e;if(!c.test(t))return null;for(var n,i,s,o,u,l,f=[],p=c.lastIndex=0;n=c.exec(t);)i=n.index,i>p&&f.push({value:t.slice(p,i)}),o=n[1].charCodeAt(0),u=42===o,l=62===o,s=u||l?n[1].slice(1):n[1],f.push({tag:!0,value:s.trim(),html:h.test(n[0]),oneTime:u,partial:l}),p=i+n[0].length;return p<t.length&&f.push({value:t.slice(p)}),a.put(t,f),f},e.tokensToExp=function(t,e){return t.length>1?t.map(function(t){return s(t,e)}).join("+"):s(t[0],e,!0)};var m=/[^|]\|[^|]/},function(t,e,n){function i(t){var e=a.get(t);if(e)return e;var n=document.createDocumentFragment(),i=t.match(u),r=l.test(t);if(i||r){var s=i&&i[1],o=h[s]||h._default,c=o[0],f=o[1],d=o[2],p=document.createElement("div");for(p.innerHTML=f+t.trim()+d;c--;)p=p.lastChild;for(var v;v=p.firstChild;)n.appendChild(v)}else n.appendChild(document.createTextNode(t));return a.put(t,n),n}function r(t){var n=t.tagName;if("TEMPLATE"===n&&t.content instanceof DocumentFragment)return t.content;if("SCRIPT"===n)return i(t.textContent);for(var r,s=e.clone(t),o=document.createDocumentFragment();r=s.firstChild;)o.appendChild(r);return o}var s=n(12),o=n(53),a=new o(1e3),c=new o(1e3),h={_default:[0,"",""],legend:[1,"<fieldset>","</fieldset>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"]};h.td=h.th=[3,"<table><tbody><tr>","</tr></tbody></table>"],h.option=h.optgroup=[1,'<select multiple="multiple">',"</select>"],h.thead=h.tbody=h.colgroup=h.caption=h.tfoot=[1,"<table>","</table>"],h.g=h.defs=h.symbol=h.use=h.image=h.text=h.circle=h.ellipse=h.line=h.path=h.polygon=h.polyline=h.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>"];var u=/<([\w:]+)/,l=/&\w+;/,f=s.inBrowser?function(){var t=document.createElement("div");return t.innerHTML="<template>1</template>",!t.cloneNode(!0).firstChild.innerHTML}():!1,d=s.inBrowser?function(){var t=document.createElement("textarea");return t.placeholder="t","t"===t.cloneNode(!0).value}():!1;e.clone=function(t){var e,n,i,r=t.cloneNode(!0);if(f&&(n=t.querySelectorAll("template"),n.length))for(i=r.querySelectorAll("template"),e=i.length;e--;)i[e].parentNode.replaceChild(n[e].cloneNode(!0),i[e]);if(d)if("TEXTAREA"===t.tagName)r.value=t.value;else if(n=t.querySelectorAll("textarea"),n.length)for(i=r.querySelectorAll("textarea"),e=i.length;e--;)i[e].value=n[e].value;return r},e.parse=function(t,n,s){var o,a;return t instanceof DocumentFragment?n?t.cloneNode(!0):t:("string"==typeof t?s||"#"!==t.charAt(0)?a=i(t):(a=c.get(t),a||(o=document.getElementById(t.slice(1)),o&&(a=r(o),c.put(t,a)))):t.nodeType&&(a=r(t)),a&&n?e.clone(a):a)}},function(t,e,n){function i(){_.raw=s.slice(p,a).trim(),void 0===_.expression?_.expression=s.slice(v,a).trim():b!==p&&r(),(0===a||_.expression)&&m.push(_)}function r(){var t,e=s.slice(b,a).trim();if(e){t={};var n=e.match(k);t.name=n[0],t.args=n.length>1?n.slice(1):null}t&&(_.filters=_.filters||[]).push(t),b=a+1}var s,o,a,c,h,u,l,f,d,p,v,m,_,b,g,y=n(12),$=n(53),w=new $(1e3),x=/^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/,k=/[^\s'"]+|'[^']+'|"[^"]+"/g;e.parse=function(t){var e=w.get(t);if(e)return e;for(s=t,h=u=!1,l=f=d=p=v=0,b=0,m=[],_={},g=null,a=0,c=s.length;c>a;a++)if(o=s.charCodeAt(a),h)39===o&&(h=!h);else if(u)34===o&&(u=!u);else if(44!==o||d||l||f)if(58!==o||_.expression||_.arg)if(124===o&&124!==s.charCodeAt(a+1)&&124!==s.charCodeAt(a-1))void 0===_.expression?(b=a+1,_.expression=s.slice(v,a).trim()):r();else switch(o){case 34:u=!0;break;case 39:h=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}else g=s.slice(p,a).trim(),x.test(g)&&(v=a+1,_.arg=y.stripQuotes(g)||g);else i(),_={},p=v=b=a+1;return(0===a||p!==a)&&i(),w.put(t,m),m}},function(t,e,n){function i(t,e){var n=C.length;return C[n]=e?t.replace(g,"\\n"):t,'"'+n+'"'}function r(t){var e=t.charAt(0),n=t.slice(1);return v.test(n)?t:(n=n.indexOf('"')>-1?n.replace($,s):n,e+"scope."+n)}function s(t,e){return C[e]}function o(t,e){_.test(t),C.length=0;var n=t.replace(y,i).replace(b,"");n=(" "+n).replace(x,r).replace($,s);var o=c(n);return o?{get:o,body:n,set:e?h(n):null}:void 0}function a(t){var e,n;return t.indexOf("[")<0?(n=t.split("."),e=l.compileGetter(n)):(n=l.parse(t),e=n.get),{get:e,set:function(t,e){l.set(t,n,e)}}}function c(t){try{return new Function("scope","return "+t+";")}catch(e){}}function h(t){try{return new Function("scope","value",t+"=value;")}catch(e){}}function u(t){t.set||(t.set=h(t.body))}var l=(n(12),n(19)),f=n(53),d=new f(1e3),p="Math,Date,this,true,false,null,undefined,Infinity,NaN,isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,parseInt,parseFloat",v=new RegExp("^("+p.replace(/,/g,"\\b|")+"\\b)"),m="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,proctected,static,interface,private,public",_=new RegExp("^("+m.replace(/,/g,"\\b|")+"\\b)"),b=/\s/g,g=/\n/g,y=/[\{,]\s*[\w\$_]+\s*:|('[^']*'|"[^"]*")|new |typeof |void /g,$=/"(\d+)"/g,w=/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\])*$/,x=/[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g,k=/^(true|false)$/,C=[];e.parse=function(t,e){t=t.trim();var n=d.get(t);if(n)return e&&u(n),n;var i=w.test(t)&&!k.test(t)&&"Math."!==t.slice(0,5)?a(t):o(t,e);return d.put(t,i),i},e.pathTestRE=w},function(t,e,n){function i(t,e,n,i,s,o){this.name=t,this.el=e,this.vm=n,this.raw=i.raw,this.expression=i.expression,this.arg=i.arg,this.filters=r.resolveFilters(n,i.filters),this._host=o,this._locked=!1,this._bound=!1,this._bind(s)}var r=n(12),s=n(16),o=n(26),a=n(20),c=n(23),h=i.prototype;h._bind=function(t){if("cloak"!==this.name&&this.el&&this.el.removeAttribute&&this.el.removeAttribute(s.prefix+this.name),"function"==typeof t?this.update=t:r.extend(this,t),this._watcherExp=this.expression,this._checkDynamicLiteral(),this.bind&&this.bind(),this._watcherExp&&(this.update||this.twoWay)&&(!this.isLiteral||this._isDynamicLiteral)&&!this._checkStatement()){var e=this,n=this._update=this.update?function(t,n){e._locked||e.update(t,n)}:function(){},i=this.vm._watchers[this.raw];i&&"repeat"!==this.name?i.addCb(n):i=this.vm._watchers[this.raw]=new o(this.vm,this._watcherExp,n,{filters:this.filters,twoWay:this.twoWay,deep:this.deep}),this._watcher=i,null!=this._initValue?i.set(this._initValue):this.update&&this.update(i.value)}this._bound=!0},h._checkDynamicLiteral=function(){var t=this.expression;if(t&&this.isLiteral){var e=a.parse(t);if(e){var n=a.tokensToExp(e);this.expression=this.vm.$get(n),this._watcherExp=n,this._isDynamicLiteral=!0}}},h._checkStatement=function(){var t=this.expression;if(t&&this.acceptStatement&&!c.pathTestRE.test(t)){var e=c.parse(t).get,n=this.vm,i=function(){e.call(n,n)};return this.filters&&(i=r.applyFilters(i,this.filters.read,n)),this.update(i),!0}},h._checkParam=function(t){var e=this.el.getAttribute(t);return null!==e&&this.el.removeAttribute(t),e},h._teardown=function(){if(this._bound){this.unbind&&this.unbind();var t=this._watcher;t&&t.active&&(t.removeCb(this._update),t.active||(this.vm._watchers[this.raw]=null)),this._bound=!1,this.vm=this.el=this._watcher=null}},h.set=function(t,e){if(this.twoWay&&(e&&(this._locked=!0),this._watcher.set(t),e)){var n=this;r.nextTick(function(){n._locked=!1})}},t.exports=i},function(t,e,n){function i(){this.id=++r,this.subs=[]}var r=0,s=n(12),o=i.prototype;o.addSub=function(t){
-this.subs.push(t)},o.removeSub=function(t){this.subs.$remove(t)},o.notify=function(){for(var t=s.toArray(this.subs),e=0,n=t.length;n>e;e++)t[e].update()},t.exports=i},function(t,e,n){function i(t,e,n,i){this.vm=t,t._watcherList.push(this),this.expression=e,this.cbs=[n],this.id=++u,this.active=!0,i=i||{},this.deep=!!i.deep,this.user=!!i.user,this.deps=Object.create(null),i.filters&&(this.readFilters=i.filters.read,this.writeFilters=i.filters.write);var r=c.parse(e,i.twoWay);this.getter=r.get,this.setter=r.set,this.value=this.get()}function r(t){var e,n,i;for(e in t)if(n=t[e],s.isArray(n))for(i=n.length;i--;)r(n[i]);else s.isObject(n)&&r(n)}var s=n(12),o=n(16),a=n(50),c=n(23),h=n(54),u=0,l=i.prototype;l.addDep=function(t){var e=t.id;this.newDeps[e]||(this.newDeps[e]=t,this.deps[e]||(this.deps[e]=t,t.addSub(this)))},l.get=function(){this.beforeGet();var t,e=this.vm;try{t=this.getter.call(e,e)}catch(n){o.warnExpressionErrors}return this.deep&&r(t),t=s.applyFilters(t,this.readFilters,e),this.afterGet(),t},l.set=function(t){var e=this.vm;t=s.applyFilters(t,this.writeFilters,e,this.value);try{this.setter.call(e,e,t)}catch(n){o.warnExpressionErrors}},l.beforeGet=function(){a.target=this,this.newDeps={}},l.afterGet=function(){a.target=null;for(var t in this.deps)this.newDeps[t]||this.deps[t].removeSub(this);this.deps=this.newDeps},l.update=function(){!o.async||o.debug?this.run():h.push(this)},l.run=function(){if(this.active){var t=this.get();if(t!==this.value||Array.isArray(t)||this.deep){var e=this.value;this.value=t;for(var n=this.cbs,i=0,r=n.length;r>i;i++){n[i](t,e);var s=r-n.length;s&&(i-=s,r-=s)}}}},l.addCb=function(t){this.cbs.push(t)},l.removeCb=function(t){var e=this.cbs;e.length>1?e.$remove(t):t===e[0]&&this.teardown()},l.teardown=function(){if(this.active){this.vm._isBeingDestroyed||this.vm._watcherList.$remove(this);for(var t in this.deps)this.deps[t].removeSub(this);this.active=!1,this.vm=this.cbs=this.value=null}},t.exports=i},function(t,e,n){function i(t,e){return e?e.toUpperCase():""}e.isReserved=function(t){var e=(t+"").charCodeAt(0);return 36===e||95===e},e.toString=function(t){return null==t?"":t.toString()},e.toNumber=function(t){return isNaN(t)||null===t||"boolean"==typeof t?t:Number(t)},e.stripQuotes=function(t){var e=t.charCodeAt(0),n=t.charCodeAt(t.length-1);return e!==n||34!==e&&39!==e?!1:t.slice(1,-1)};var r=/-(\w)/g;e.camelize=function(t){return t.replace(r,i)};var s=/(?:^|[-_\/])(\w)/g;e.classify=function(t){return t.replace(s,i)},e.bind=function(t,e){return function(){return t.apply(e,arguments)}},e.toArray=function(t,e){e=e||0;for(var n=t.length-e,i=new Array(n);n--;)i[n]=t[n+e];return i},e.extend=function(t,e){for(var n in e)t[n]=e[n];return t},e.isObject=function(t){return t&&"object"==typeof t};var o=Object.prototype.toString;e.isPlainObject=function(t){return"[object Object]"===o.call(t)},e.isArray=function(t){return Array.isArray(t)},e.define=function(t,e,n,i){Object.defineProperty(t,e,{value:n,enumerable:!!i,writable:!0,configurable:!0})},e.debounce=function(t,e){var n,i,r,s,o,a=function(){var c=Date.now()-s;e>c&&c>=0?n=setTimeout(a,e-c):(n=null,o=t.apply(r,i),n||(r=i=null))};return function(){return r=this,i=arguments,s=Date.now(),n||(n=setTimeout(a,e)),o}}},function(t,e,n){e.hasProto="__proto__"in{};var i=Object.prototype.toString,r=e.inBrowser="undefined"!=typeof window&&"[object Object]"!==i.call(window);if(e.nextTick=function(){function t(){i=!1;var t=n.slice(0);n=[];for(var e=0;e<t.length;e++)t[e]()}var e,n=[],i=!1;if("undefined"!=typeof MutationObserver){var r=1,s=new MutationObserver(t),o=document.createTextNode(r);s.observe(o,{characterData:!0}),e=function(){r=(r+1)%2,o.data=r}}else e=setTimeout;return function(r,s){var o=s?function(){r.call(s)}:r;n.push(o),i||(i=!0,e(t,0))}}(),e.isIE9=r&&navigator.userAgent.indexOf("MSIE 9.0")>0,r&&!e.isIE9){var s=void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend,o=void 0===window.onanimationend&&void 0!==window.onwebkitanimationend;e.transitionProp=s?"WebkitTransition":"transition",e.transitionEndEvent=s?"webkitTransitionEnd":"transitionend",e.animationProp=o?"WebkitAnimation":"animation",e.animationEndEvent=o?"webkitAnimationEnd":"animationend"}},function(t,e,n){var i=n(16),r="undefined"!=typeof document&&document.documentElement;e.inDoc=function(t){var e=t&&t.parentNode;return r===t||r===e||!(!e||1!==e.nodeType||!r.contains(e))},e.attr=function(t,e){e=i.prefix+e;var n=t.getAttribute(e);return null!==n&&t.removeAttribute(e),n},e.before=function(t,e){e.parentNode.insertBefore(t,e)},e.after=function(t,n){n.nextSibling?e.before(t,n.nextSibling):n.parentNode.appendChild(t)},e.remove=function(t){t.parentNode.removeChild(t)},e.prepend=function(t,n){n.firstChild?e.before(t,n.firstChild):n.appendChild(t)},e.replace=function(t,e){var n=t.parentNode;n&&n.replaceChild(e,t)},e.on=function(t,e,n){t.addEventListener(e,n)},e.off=function(t,e,n){t.removeEventListener(e,n)},e.addClass=function(t,e){if(t.classList)t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}},e.removeClass=function(t,e){if(t.classList)t.classList.remove(e);else{for(var n=" "+(t.getAttribute("class")||"")+" ",i=" "+e+" ";n.indexOf(i)>=0;)n=n.replace(i," ");t.setAttribute("class",n.trim())}},e.extractContent=function(t,e){var n,i;if("TEMPLATE"===t.tagName&&t.content instanceof DocumentFragment&&(t=t.content),t.hasChildNodes())for(i=e?document.createDocumentFragment():document.createElement("div");n=t.firstChild;)i.appendChild(n);return i}},function(t,e,n){n(31);e.resolveFilters=function(t,e,n){if(e){var i=n||{};return e.forEach(function(e){var n=t.$options.filters[e.name];if(n){var r,s,o=e.args;"function"==typeof n?r=n:(r=n.read,s=n.write),r&&(i.read||(i.read=[]),i.read.push(function(e){return o?r.apply(t,[e].concat(o)):r.call(t,e)})),s&&(i.write||(i.write=[]),i.write.push(function(e,n){return o?s.apply(t,[e,n].concat(o)):s.call(t,e,n)}))}}),i}},e.applyFilters=function(t,e,n,i){if(!e)return t;for(var r=0,s=e.length;s>r;r++)t=e[r].call(n,t,i);return t}},function(t,e,n){n(16)},function(t,e,n){var i=n(12);t.exports={bind:function(){this.attr=3===this.el.nodeType?"nodeValue":"textContent"},update:function(t){this.el[this.attr]=i.toString(t)}}},function(t,e,n){var i=n(12),r=n(21);t.exports={bind:function(){8===this.el.nodeType&&(this.nodes=[])},update:function(t){t=i.toString(t),this.nodes?this.swap(t):this.el.innerHTML=t},swap:function(t){for(var e=this.nodes.length;e--;)i.remove(this.nodes[e]);var n=r.parse(t,!0,!0);this.nodes=i.toArray(n.childNodes),i.before(n,this.el)}}},function(t,e,n){function i(t){t||0===t?this.el.setAttribute(this.arg,t):this.el.removeAttribute(this.arg)}function r(t){null!=t?this.el.setAttributeNS(s,this.arg,t):this.el.removeAttributeNS(s,"href")}var s="http://www.w3.org/1999/xlink",o=/^xlink:/;t.exports={priority:850,bind:function(){var t=this.arg;this.update=o.test(t)?r:i}}},function(t,e,n){var i=n(51);t.exports=function(t){var e=this.el;i.apply(e,t?1:-1,function(){e.style.display=t?"":"none"},this.vm)}},function(t,e,n){var i=n(12),r=i.addClass,s=i.removeClass;t.exports=function(t){if(this.arg){var e=t?r:s;e(this.el,this.arg)}else this.lastVal&&s(this.el,this.lastVal),t&&(r(this.el,t),this.lastVal=t)}},function(t,e,n){t.exports={isLiteral:!0,bind:function(){this.vm.$$[this.expression]=this.el},unbind:function(){delete this.vm.$$[this.expression]}}},function(t,e,n){n(12);t.exports={isLiteral:!0,bind:function(){var t=this.el.__vue__;t&&(t._refID=this.expression)}}},function(t,e,n){var i=n(16);t.exports={bind:function(){var t=this.el;this.vm.$once("hook:compiled",function(){t.removeAttribute(i.prefix+"cloak")})}}},function(t,e,n){function i(t){if(l[t])return l[t];var e=r(t);return l[t]=l[e]=e,e}function r(t){t=t.replace(h,"$1-$2").toLowerCase();var e=s.camelize(t),n=e.charAt(0).toUpperCase()+e.slice(1);if(u||(u=document.createElement("div")),e in u.style)return t;for(var i,r=o.length;r--;)if(i=a[r]+n,i in u.style)return o[r]+t}var s=n(12),o=["-webkit-","-moz-","-ms-"],a=["Webkit","Moz","ms"],c=/!important;?$/,h=/([a-z])([A-Z])/g,u=null,l={};t.exports={deep:!0,update:function(t){if(this.arg)this.setProp(this.arg,t);else if("object"==typeof t){this.cache||(this.cache={});for(var e in t)this.setProp(e,t[e]),t[e]!=this.cache[e]&&(this.cache[e]=t[e],this.setProp(e,t[e]))}else this.el.style.cssText=t},setProp:function(t,e){if(t=i(t))if(null!=e&&(e+=""),e){var n=c.test(e)?"important":"";n&&(e=e.replace(c,"").trim()),this.el.style.setProperty(t,e,n)}else this.el.style.removeProperty(t)}}},function(t,e,n){var i=n(12),r=n(21),s=n(46);t.exports={isLiteral:!0,compile:s.compile,teardown:s.teardown,getContainedComponents:s.getContainedComponents,unbind:s.unbind,bind:function(){var t=this.el;this.start=document.createComment("v-partial-start"),this.end=document.createComment("v-partial-end"),8!==t.nodeType&&(t.innerHTML=""),"TEMPLATE"===t.tagName||8===t.nodeType?i.replace(t,this.end):t.appendChild(this.end),i.before(this.start,this.end),this._isDynamicLiteral||this.insert(this.expression)},update:function(t){this.teardown(),this.insert(t)},insert:function(t){var e=this.vm.$options.partials[t];if(e){var n=this.filters&&this.filters.read;n&&(e=i.applyFilters(e,n,this.vm)),this.compile(r.parse(e,!0))}}}},function(t,e,n){t.exports={priority:1e3,isLiteral:!0,bind:function(){this._isDynamicLiteral||this.update(this.expression)},update:function(t){var e=this.el.__vue__||this.vm;this.el.__v_trans={id:t,fns:e.$options.transitions[t]}}}},function(t,e,n){var i=n(12);t.exports={acceptStatement:!0,priority:700,bind:function(){if("IFRAME"===this.el.tagName&&"load"!==this.arg){var t=this;this.iframeBind=function(){i.on(t.el.contentWindow,t.arg,t.handler)},i.on(this.el,"load",this.iframeBind)}},update:function(t){if("function"==typeof t){this.reset();var e=this.vm;this.handler=function(n){n.targetVM=e,e.$event=n;var i=t(n);return e.$event=null,i},this.iframeBind?this.iframeBind():i.on(this.el,this.arg,this.handler)}},reset:function(){var t=this.iframeBind?this.el.contentWindow:this.el;this.handler&&i.off(t,this.arg,this.handler)},unbind:function(){this.reset(),i.off(this.el,"load",this.iframeBind)}}},function(t,e,n){var i=n(12),r=n(21);t.exports={isLiteral:!0,bind:function(){this.el.__vue__||(this.ref=document.createComment("v-component"),i.replace(this.el,this.ref),this.keepAlive=null!=this._checkParam("keep-alive"),this.refID=i.attr(this.el,"ref"),this.keepAlive&&(this.cache={}),null!==this._checkParam("inline-template")&&(this.template=i.extractContent(this.el,!0)),this._isDynamicLiteral?(this.readyEvent=this._checkParam("wait-for"),this.transMode=this._checkParam("transition-mode")):this.resolveCtor(this.expression,function(){var t=this.build();t.$before(this.ref),this.setCurrent(t)}.bind(this)))},resolveCtor:function(t,e){this.ctorId=t;var n=this;this.vm._resolveComponent(t,function(t){n.Ctor=t,e()})},build:function(){if(this.keepAlive){var t=this.cache[this.ctorId];if(t)return t}var e=this.vm,n=r.clone(this.el);if(this.Ctor){var i=e.$addChild({el:n,template:this.template,_asComponent:!0,_host:this._host},this.Ctor);return this.keepAlive&&(this.cache[this.ctorId]=i),i}},unbuild:function(){var t=this.childVM;t&&!this.keepAlive&&t.$destroy(!1,!0)},remove:function(t,e){var n=this.keepAlive;t?t.$remove(function(){n||t._cleanup(),e&&e()}):e&&e()},update:function(t){if(t){this.resolveCtor(t),this.unbuild();var e=this.build(),n=this;this.readyEvent?e.$once(this.readyEvent,function(){n.swapTo(e)}):this.swapTo(e)}else this.unbuild(),this.remove(this.childVM),this.unsetCurrent()},swapTo:function(t){var e=this,n=this.childVM;switch(this.unsetCurrent(),this.setCurrent(t),e.transMode){case"in-out":t.$before(e.ref,function(){e.remove(n)});break;case"out-in":e.remove(n,function(){t.$before(e.ref)});break;default:e.remove(n),t.$before(e.ref)}},setCurrent:function(t){this.childVM=t;var e=t._refID||this.refID;e&&(this.vm.$[e]=t)},unsetCurrent:function(){var t=this.childVM;this.childVM=null;var e=t&&t._refID||this.refID;e&&(this.vm.$[e]=null)},unbind:function(){if(this.unbuild(),this.cache){for(var t in this.cache)this.cache[t].$destroy();this.cache=null}}}},function(t,e,n){function i(t,e){for(var n=(t._blockEnd||t.$el).nextSibling;!n.__vue__&&n!==e;)n=n.nextSibling;return n.__vue__}function r(t){if(this.rawValue=t,!c(t))return t;for(var e,n=Object.keys(t),i=n.length,r=new Array(i);i--;)e=n[i],r[i]={$key:e,$value:t[e]};return this.converted=!0,r}function s(t){for(var e=-1,n=new Array(t);++e<t;)n[e]=e;return n}var o=n(12),a=o.isObject,c=o.isPlainObject,h=n(20),u=n(23),l=n(21),f=n(17),d=n(18),p=n(15),v=0;t.exports={bind:function(){this.id="__v_repeat_"+ ++v,this.filters||(this.filters={});var t=o.bind(r,this);this.filters.read?this.filters.read.unshift(t):this.filters.read=[t],this.ref=document.createComment("v-repeat"),o.replace(this.el,this.ref),this.template="TEMPLATE"===this.el.tagName?l.parse(this.el,!0):this.el,this.checkIf(),this.checkRef(),this.checkComponent(),this.idKey=this._checkParam("track-by")||this._checkParam("trackby"),this.cache=Object.create(null)},checkIf:function(){null!==o.attr(this.el,"if")},checkRef:function(){var t=o.attr(this.el,"ref");this.refID=t?this.vm.$interpolate(t):null;var e=o.attr(this.el,"el");this.elId=e?this.vm.$interpolate(e):null},checkComponent:function(){var t=o.attr(this.el,"component"),e=this.vm.$options;if(t){this.asComponent=!0,null!==this._checkParam("inline-template")&&(this.inlineTempalte=o.extractContent(this.el,!0));var n=h.parse(t);if(n){var i=h.tokensToExp(n);this.ctorGetter=u.parse(i).get}else{var r=this.Ctor=e.components[t],s=p(r.options,{},{$parent:this.vm});s.template=this.inlineTempalte||s.template,s._asComponent=!0,s._parent=this.vm,this.template=d(this.template,s),this.template.__vue__=!0,this._linkFn=f(this.template,s)}}else{this.Ctor=o.Vue,this.inherit=!0,this.template=d(this.template);var a=o.extend({},e);a._asComponent=!1,this._linkFn=f(this.template,a)}},update:function(t){t=t||[];var e=typeof t;"number"===e?t=s(t):"string"===e&&(t=o.toArray(t)),this.vms=this.diff(t,this.vms),this.refID&&(this.vm.$[this.refID]=this.vms),this.elId&&(this.vm.$$[this.elId]=this.vms.map(function(t){return t.$el}))},diff:function(t,e){var n,r,s,o,a,c=this.idKey,h=this.converted,u=this.ref,l=this.arg,f=!e,d=new Array(t.length);for(o=0,a=t.length;a>o;o++)n=t[o],r=h?n.$value:n,s=!f&&this.getVm(r),s?(s._reused=!0,s.$index=o,h&&(s.$key=n.$key),c&&(l?s[l]=r:s._setData(r))):(s=this.build(n,o,!0),s._new=!0,s._reused=!1),d[o]=s,f&&s.$before(u);if(f)return d;for(o=0,a=e.length;a>o;o++)s=e[o],s._reused||(this.uncacheVm(s),s.$destroy(!0));var p,v;for(o=d.length;o--;){if(s=d[o],p=d[o+1]){var m=p.$el;s._reused?(v=i(s,u),v!==p&&s.$before(m,null,!1)):s.$before(m)}else s._reused||s.$before(u);s._new=!1,s._reused=!1}return d},build:function(t,e,n){var i={$index:e};this.converted&&(i.$key=t.$key);var r=this.converted?t.$value:t,s=this.arg;s?(t={},t[s]=r):c(r)?t=r:(t={},i.$value=r);var o=this.Ctor||this.resolveCtor(t,i),a=this.vm.$addChild({el:l.clone(this.template),_asComponent:this.asComponent,_host:this._host,_linkFn:this._linkFn,_meta:i,data:t,inherit:this.inherit,template:this.inlineTempalte},o);a._repeat=!0,n&&this.cacheVm(r,a);var h=this;return a.$watch("$value",function(t){h.converted?h.rawValue[a.$key]=t:h.rawValue.$set(a.$index,t)}),a},resolveCtor:function(t,e){var n,i=Object.create(this.vm);for(n in t)o.define(i,n,t[n]);for(n in e)o.define(i,n,e[n]);var r=this.ctorGetter.call(i,i),s=this.vm.$options.components[r];return s},unbind:function(){if(this.refID&&(this.vm.$[this.refID]=null),this.vms)for(var t,e=this.vms.length;e--;)t=this.vms[e],this.uncacheVm(t),t.$destroy()},cacheVm:function(t,e){var n,i=this.idKey,r=this.cache;i?(n=t[i],r[n]||(r[n]=e)):a(t)?(n=this.id,t.hasOwnProperty(n)?null===t[n]&&(t[n]=e):o.define(t,this.id,e)):r[t]?r[t].push(e):r[t]=[e],e._raw=t},getVm:function(t){if(this.idKey)return this.cache[t[this.idKey]];if(a(t))return t[this.id];var e=this.cache[t];if(e){for(var n=0,i=e[n];i&&(i._reused||i._new);)i=e[++n];return i}},uncacheVm:function(t){var e=t._raw;this.idKey?this.cache[e[this.idKey]]=null:a(e)?(e[this.id]=null,t._raw=null):this.cache[e].pop()}}},function(t,e,n){function i(t){t._isAttached||t._callHook("attached")}function r(t){t._isAttached&&t._callHook("detached")}var s=n(12),o=n(17),a=n(21),c=n(51);t.exports={bind:function(){var t=this.el;t.__vue__?this.invalid=!0:(this.start=document.createComment("v-if-start"),this.end=document.createComment("v-if-end"),s.replace(t,this.end),s.before(this.start,this.end),"TEMPLATE"===t.tagName?this.template=a.parse(t,!0):(this.template=document.createDocumentFragment(),this.template.appendChild(a.clone(t))),this.linker=o(this.template,this.vm.$options,!0))},update:function(t){if(!this.invalid)if(t){if(!this.unlink){var e=a.clone(this.template);this.compile(e)}}else this.teardown()},compile:function(t){var e=this.vm;if(this.unlink=this.linker?this.linker(e,t):e.$compile(t),c.blockAppend(t,this.end,e),s.inDoc(e.$el)){var n=this.getContainedComponents();n&&n.forEach(i)}},teardown:function(){if(this.unlink){var t;s.inDoc(this.vm.$el)&&(t=this.getContainedComponents()),c.blockRemove(this.start,this.end,this.vm),t&&t.forEach(r),this.unlink(),this.unlink=null}},getContainedComponents:function(){function t(t){for(var e,r=n;e!==i;){if(e=r.nextSibling,r.contains(t.$el))return!0;r=e}return!1}var e=this.vm,n=this.start.nextSibling,i=this.end,r=e._children.length&&e._children.filter(t),s=e._transCpnts&&e._transCpnts.filter(t);return r?s?r.concat(s):r:s},unbind:function(){this.unlink&&this.unlink()}}},function(t,e,n){var i=n(12),r=n(26),s=n(23),o=/^(true|false|\s?('[^']*'|"[^"]")\s?)$/;t.exports={priority:900,bind:function(){var t=this.vm,e=t.$parent,n=this.arg||"$data",a=this.expression;if(this.el&&this.el!==t.$el);else if(e)if(o.test(a))if(this.arg){var c=s.parse(a).get();t.$set(n,c)}else;else{var h=!1,u=function(){h=!0,i.nextTick(l)},l=function(){h=!1};this.parentWatcher=new r(e,a,function(e){h||(u(),t.$set(n,e))}),t.$set(n,this.parentWatcher.value),this.childWatcher=new r(t,n,function(t){h||(u(),e.$set(a,t))})}else;},unbind:function(){this.parentWatcher&&(this.parentWatcher.teardown(),this.childWatcher.teardown())}}},function(t,e,n){n(12);t.exports={acceptStatement:!0,bind:function(){var t=this.el.__vue__;!t||this.vm!==t.$parent},update:function(t,e){if("function"==typeof t){var n=this.el.__vue__;e&&n.$off(this.arg,e),n.$on(this.arg,t)}}}},function(t,e,n){function i(t,e){if(r.isObject(t)){for(var n in t)if(i(t[n],e))return!0}else if(null!=t)return t.toString().toLowerCase().indexOf(e)>-1}var r=n(12),s=n(19);e.filterBy=function(t,e,n,o){n&&"in"!==n&&(o=n);var a=r.stripQuotes(e)||this.$get(e);return a?(a=(""+a).toLowerCase(),o=o&&(r.stripQuotes(o)||this.$get(o)),t.filter(function(t){return o?i(s.get(t,o),a):i(t,a)})):t},e.orderBy=function(t,e,n){var i=r.stripQuotes(e)||this.$get(e);if(!i)return t;var o=1;return n&&("-1"===n?o=-1:33===n.charCodeAt(0)?(n=n.slice(1),o=this.$get(n)?1:-1):o=this.$get(n)?-1:1),t.slice().sort(function(t,e){return"$key"!==i&&"$value"!==i&&(t&&"$value"in t&&(t=t.$value),e&&"$value"in e&&(e=e.$value)),t=r.isObject(t)?s.get(t,i):t,e=r.isObject(e)?s.get(e,i):e,t===e?0:t>e?o:-o})}},function(t,e,n){function i(t,e){t.__proto__=e}function r(t,e,n){for(var i,r=n.length;r--;)i=n[r],o.define(t,i,e[i])}function s(t,e){if(this.id=++l,this.value=t,this.active=!0,this.deps=[],o.define(t,"__ob__",this),e===f){var n=a.proto&&o.hasProto?i:r;n(t,h,u),this.observeArray(t)}else e===d&&this.walk(t)}var o=n(12),a=n(16),c=n(25),h=n(55),u=Object.getOwnPropertyNames(h);n(56);var l=0,f=0,d=1;s.target=null;var p=s.prototype;s.create=function(t){return t&&t.hasOwnProperty("__ob__")&&t.__ob__ instanceof s?t.__ob__:o.isArray(t)?new s(t,f):o.isPlainObject(t)&&!t._isVue?new s(t,d):void 0},p.walk=function(t){for(var e,n,i=Object.keys(t),r=i.length;r--;)e=i[r],n=e.charCodeAt(0),36!==n&&95!==n&&this.convert(e,t[e])},p.observe=function(t){return s.create(t)},p.observeArray=function(t){for(var e=t.length;e--;)this.observe(t[e])},p.convert=function(t,e){var n=this,i=n.observe(e),r=new c;i&&i.deps.push(r),Object.defineProperty(n.value,t,{enumerable:!0,configurable:!0,get:function(){return n.active&&s.target&&s.target.addDep(r),e},set:function(t){if(t!==e){var i=e&&e.__ob__;i&&i.deps.$remove(r),e=t;var s=n.observe(t);s&&s.deps.push(r),r.notify()}}})},p.notify=function(){for(var t=this.deps,e=0,n=t.length;n>e;e++)t[e].notify()},p.addVm=function(t){(this.vms=this.vms||[]).push(t)},p.removeVm=function(t){this.vms.$remove(t)},t.exports=s},function(t,e,n){var i=n(12),r=n(57),s=n(58),o="undefined"==typeof document?null:document;e.append=function(t,e,n,i){a(t,1,function(){e.appendChild(t)},n,i)},e.before=function(t,e,n,r){a(t,1,function(){i.before(t,e)},n,r)},e.remove=function(t,e,n){a(t,-1,function(){i.remove(t)},e,n)},e.removeThenAppend=function(t,e,n,i){a(t,-1,function(){e.appendChild(t)},n,i)},e.blockAppend=function(t,n,r){for(var s=i.toArray(t.childNodes),o=0,a=s.length;a>o;o++)e.before(s[o],n,r)},e.blockRemove=function(t,n,i){for(var r,s=t.nextSibling;s!==n;)r=s.nextSibling,e.remove(s,i),s=r};var a=e.apply=function(t,e,n,a,c){var h=t.__v_trans;if(!h||!a._isCompiled||a.$parent&&!a.$parent._isCompiled)return n(),void(c&&c());var u=h.fns;u?s(t,e,n,h,u,a,c):!i.transitionEndEvent||o&&o.hidden?(n(),c&&c()):r(t,e,n,h,c)}},function(t,e,n){var i=(n(12),{_default:n(59),radio:n(60),select:n(61),checkbox:n(62)});t.exports={priority:800,twoWay:!0,handlers:i,bind:function(){var t=this.filters;t&&t.read&&!t.write;var e,n=this.el,r=n.tagName;if("INPUT"===r)e=i[n.type]||i._default;else if("SELECT"===r)e=i.select;else{if("TEXTAREA"!==r)return;e=i._default}e.bind.call(this),this.update=e.update,this.unbind=e.unbind}}},function(t,e,n){function i(t){this.size=0,this.limit=t,this.head=this.tail=void 0,this._keymap={}}var r=i.prototype;r.put=function(t,e){var n={key:t,value:e};return this._keymap[t]=n,this.tail?(this.tail.newer=n,n.older=this.tail):this.head=n,this.tail=n,this.size===this.limit?this.shift():void this.size++},r.shift=function(){var t=this.head;return t&&(this.head=this.head.newer,this.head.older=void 0,t.newer=t.older=void 0,this._keymap[t.key]=void 0),t},r.get=function(t,e){var n=this._keymap[t];if(void 0!==n)return n===this.tail?e?n:n.value:(n.newer&&(n===this.head&&(this.head=n.newer),n.newer.older=n.older),n.older&&(n.older.newer=n.newer),n.newer=void 0,n.older=this.tail,this.tail&&(this.tail.newer=n),this.tail=n,e?n:n.value)},t.exports=i},function(t,e,n){function i(){c=[],h=[],u={},l=!1,f=!1}function r(){f=!0,s(c),s(h),i()}function s(t){for(var e=0;e<t.length;e++)t[e].run()}var o=n(12),a=10,c=[],h=[],u={},l=!1,f=!1;e.push=function(t){var e=t.id;if(!e||!u[e]||f){if(u[e]){if(u[e]++,u[e]>a)return}else u[e]=1;if(f&&!t.user)return void t.run();(t.user?h:c).push(t),l||(l=!0,o.nextTick(r))}}},function(t,e,n){var i=n(12),r=Array.prototype,s=Object.create(r);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=r[t];i.define(s,t,function(){for(var n=arguments.length,i=new Array(n);n--;)i[n]=arguments[n];var r,s=e.apply(this,i),o=this.__ob__;switch(t){case"push":r=i;break;case"unshift":r=i;break;case"splice":r=i.slice(2)}return r&&o.observeArray(r),o.notify(),s})}),i.define(r,"$set",function(t,e){return t>=this.length&&(this.length=t+1),this.splice(t,1,e)[0]}),i.define(r,"$remove",function(t){this.length&&("number"!=typeof t&&(t=this.indexOf(t)),t>-1&&this.splice(t,1))}),t.exports=s},function(t,e,n){var i=n(12),r=Object.prototype;i.define(r,"$add",function(t,e){if(!this.hasOwnProperty(t)){var n=this.__ob__;if(!n||i.isReserved(t))return void(this[t]=e);if(n.convert(t,e),n.vms)for(var r=n.vms.length;r--;){var s=n.vms[r];s._proxy(t),s._digest()}else n.notify()}}),i.define(r,"$set",function(t,e){this.$add(t,e),this[t]=e}),i.define(r,"$delete",function(t){if(this.hasOwnProperty(t)){delete this[t];var e=this.__ob__;if(e&&!i.isReserved(t))if(e.vms)for(var n=e.vms.length;n--;){var r=e.vms[n];r._unproxy(t),r._digest()}else e.notify()}})},function(t,e,n){function i(t,e,n,i,s){f.push({el:t,dir:e,cb:s,cls:i,op:n}),d||(d=!0,a.nextTick(r))}function r(){document.documentElement.offsetHeight;f.forEach(s),f=[],d=!1}function s(t){function e(t,e){i.event=t;var r=i.callback=function(o){o.target===n&&(a.off(n,t,r),i.event=i.callback=null,e&&e(),s&&s())};a.on(n,t,r)}var n=t.el,i=n.__v_trans,r=t.cls,s=t.cb,c=t.op,u=o(n,i,r);if(t.dir>0)1===u?(h(n,r),s&&e(a.transitionEndEvent)):2===u?e(a.animationEndEvent,function(){h(n,r)}):(h(n,r),s&&s());else if(u){var l=1===u?a.transitionEndEvent:a.animationEndEvent;e(l,function(){c(),h(n,r)})}else c(),h(n,r),s&&s()}function o(t,e,n){var i=e.cache&&e.cache[n];if(i)return i;var r=t.style,s=window.getComputedStyle(t),o=r[u]||s[u];if(o&&"0s"!==o)i=1;else{var a=r[l]||s[l];a&&"0s"!==a&&(i=2)}return i&&(e.cache||(e.cache={}),e.cache[n]=i),i}var a=n(12),c=a.addClass,h=a.removeClass,u=a.transitionProp+"Duration",l=a.animationProp+"Duration",f=[],d=!1;t.exports=function(t,e,n,r,s){var o=r.id||"v",u=o+"-enter",l=o+"-leave";r.callback&&(a.off(t,r.event,r.callback),h(t,u),h(t,l),r.event=r.callback=null),e>0?(c(t,u),n(),i(t,e,null,u,s)):(c(t,l),i(t,e,n,l,s))}},function(t,e,n){t.exports=function(t,e,n,i,r,s,o){s=t.__vue__||s,i.cancel&&(i.cancel(),i.cancel=null),e>0?(r.beforeEnter&&r.beforeEnter.call(s,t),n(),r.enter?i.cancel=r.enter.call(s,t,function(){i.cancel=null,o&&o()}):o&&o()):r.leave?i.cancel=r.leave.call(s,t,function(){i.cancel=null,n(),o&&o()}):(n(),o&&o())}},function(t,e,n){var i=n(12);t.exports={bind:function(){function t(){e.set(s?i.toNumber(n.value):n.value,!0)}var e=this,n=this.el,r=null!=this._checkParam("lazy"),s=null!=this._checkParam("number"),o=parseInt(this._checkParam("debounce"),10),a=!1;this.cpLock=function(){a=!0},this.cpUnlock=function(){a=!1,t()},i.on(n,"compositionstart",this.cpLock),i.on(n,"compositionend",this.cpUnlock);var c=this.filters&&this.filters.read;this.listener=c||"range"===n.type?function(){if(!a){var r;try{r=n.value.length-n.selectionStart}catch(s){}0>r||(t(),i.nextTick(function(){var t=e._watcher.value;if(e.update(t),null!=r){var s=i.toString(t).length-r;n.setSelectionRange(s,s)}}))}}:function(){a||t()},o&&(this.listener=i.debounce(this.listener,o)),this.event=r?"change":"input",this.hasjQuery="function"==typeof jQuery,this.hasjQuery?jQuery(n).on(this.event,this.listener):i.on(n,this.event,this.listener),!r&&i.isIE9&&(this.onCut=function(){i.nextTick(e.listener)},this.onDel=function(t){(46===t.keyCode||8===t.keyCode)&&e.listener()},i.on(n,"cut",this.onCut),i.on(n,"keyup",this.onDel)),(n.hasAttribute("value")||"TEXTAREA"===n.tagName&&n.value.trim())&&(this._initValue=s?i.toNumber(n.value):n.value)},update:function(t){this.el.value=i.toString(t)},unbind:function(){var t=this.el;this.hasjQuery?jQuery(t).off(this.event,this.listener):i.off(t,this.event,this.listener),i.off(t,"compositionstart",this.cpLock),i.off(t,"compositionend",this.cpUnlock),this.onCut&&(i.off(t,"cut",this.onCut),i.off(t,"keyup",this.onDel))}}},function(t,e,n){var i=n(12);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.value,!0)},i.on(e,"change",this.listener),e.checked&&(this._initValue=e.value)},update:function(t){this.el.checked=t==this.el.value},unbind:function(){i.off(this.el,"change",this.listener)}}},function(t,e,n){function i(t){function e(t){u.isArray(t)&&(n.el.innerHTML="",r(n.el,t),n._watcher&&n.update(n._watcher.value))}var n=this,i=f.parse(t)[0];this.optionWatcher=new l(this.vm,i.expression,e,{deep:!0,filters:u.resolveFilters(this.vm,i.filters)}),e(this.optionWatcher.value)}function r(t,e){for(var n,i,s=0,o=e.length;o>s;s++)n=e[s],n.options?(i=document.createElement("optgroup"),i.label=n.label,r(i,n.options)):(i=document.createElement("option"),"string"==typeof n?i.text=i.value=n:(i.text=n.text,i.value=n.value)),t.appendChild(i)}function s(){for(var t,e=this.el.options,n=0,i=e.length;i>n;n++)e[n].hasAttribute("selected")&&(this.multiple?(t||(t=[])).push(e[n].value):t=e[n].value);"undefined"!=typeof t&&(this._initValue=this.number?u.toNumber(t):t)}function o(t){return Array.prototype.filter.call(t.options,a).map(c)}function a(t){return t.selected}function c(t){return t.value||t.text}function h(t,e){for(var n=t.length;n--;)if(t[n]==e)return n;return-1}var u=n(12),l=n(26),f=n(22);t.exports={bind:function(){var t=this,e=this.el,n=this._checkParam("options");n&&i.call(this,n),this.number=null!=this._checkParam("number"),this.multiple=e.hasAttribute("multiple"),this.listener=function(){var n=t.multiple?o(e):e.value;n=t.number?u.isArray(n)?n.map(u.toNumber):u.toNumber(n):n,t.set(n,!0)},u.on(e,"change",this.listener),s.call(this)},update:function(t){var e=this.el;e.selectedIndex=-1;for(var n,i=this.multiple&&u.isArray(t),r=e.options,s=r.length;s--;)n=r[s],n.selected=i?h(t,n.value)>-1:t==n.value},unbind:function(){u.off(this.el,"change",this.listener),this.optionWatcher&&this.optionWatcher.teardown()}}},function(t,e,n){var i=n(12);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.checked,!0)},i.on(e,"change",this.listener),e.checked&&(this._initValue=e.checked)},update:function(t){this.el.checked=!!t},unbind:function(){i.off(this.el,"change",this.listener)}}}])});
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):"object"==typeof exports?exports.Vue=e():t.Vue=e()}(this,function(){return function(t){function e(i){if(n[i])return n[i].exports;var r=n[i]={exports:{},id:i,loaded:!1};return t[i].call(r.exports,r,r.exports,e),r.loaded=!0,r.exports}var n={};return e.m=t,e.c=n,e.p="",e(0)}([function(t,e,n){function i(t){this._init(t)}var r=n(2),s=r.extend;s(i,n(27)),i.options={directives:n(28),filters:n(51),transitions:{},components:{},elementDirectives:{}};var o=i.prototype;Object.defineProperty(o,"$data",{get:function(){return this._data},set:function(t){t!==this._data&&this._setData(t)}}),s(o,n(53)),s(o,n(54)),s(o,n(55)),s(o,n(1)),s(o,n(56)),s(o,n(57)),s(o,n(58)),s(o,n(59)),s(o,n(60)),s(o,n(61)),t.exports=r.Vue=i},function(t,e,n){var i=n(2),r=n(10),s=n(22),o=n(26);e._compile=function(t){var e=this.$options;if(e._linkFn)this._initElement(t),this._unlinkFn=e._linkFn(this,t);else{var n=t;t=o(t,e),this._initElement(t),this._unlinkFn=s(t,e)(this,t),e.replace&&i.replace(n,t)}return t},e._initElement=function(t){t instanceof DocumentFragment?(this._isBlock=!0,this.$el=this._blockStart=t.firstChild,this._blockEnd=t.lastChild,3===this._blockStart.nodeType&&(this._blockStart.data=this._blockEnd.data=""),this._blockFragment=t):this.$el=t,this.$el.__vue__=this,this._callHook("beforeCompile")},e._bindDir=function(t,e,n,i,s){this._directives.push(new r(t,e,this,n,i,s))},e._destroy=function(t,e){if(!this._isBeingDestroyed){this._callHook("beforeDestroy"),this._isBeingDestroyed=!0;var n,i=this.$parent;i&&!i._isBeingDestroyed&&i._children.$remove(this);var r=this._host;for(r&&!r._isBeingDestroyed&&r._transCpnts.$remove(this),n=this._children.length;n--;)this._children[n].$destroy();for(this._unlinkFn&&this._unlinkFn(!0),n=this._watchers.length;n--;)this._watchers[n].teardown();this.$el&&(this.$el.__vue__=null);var s=this;t&&this.$el?this.$remove(function(){s._cleanup()}):e||this._cleanup()}},e._cleanup=function(){this._data.__ob__.removeVm(this),this._data=this._watchers=this.$el=this.$parent=this.$root=this._children=this._transCpnts=this._directives=null,this._isDestroyed=!0,this._callHook("destroyed"),this.$off()}},function(t,e,n){var i=n(5),r=i.extend;r(e,i),r(e,n(6)),r(e,n(7)),r(e,n(3)),r(e,n(8)),r(e,n(9))},function(t,e,n){var i=n(2),r=n(4),s=/^(div|p|span|img|a|br|ul|ol|li|h1|h2|h3|h4|h5|table|tbody|tr|td|pre)$/;e.checkComponent=function(t,e){var n=t.tagName.toLowerCase();if("component"===n){var r=t.getAttribute("is");return t.removeAttribute("is"),r}return!s.test(n)&&i.resolveAsset(e,"components",n)?n:void 0},e.createAnchor=function(t,e){return r.debug?document.createComment(t):document.createTextNode(e?" ":"")}},function(t,e,n){t.exports={prefix:"v-",debug:!1,silent:!1,proto:!0,interpolate:!0,async:!0,warnExpressionErrors:!0,_delimitersChanged:!0,_assetTypes:["directive","elementDirective","filter","transition"]};var i=["{{","}}"];Object.defineProperty(t.exports,"delimiters",{get:function(){return i},set:function(t){i=t,this._delimitersChanged=!0}})},function(t,e,n){function i(t,e){return e?e.toUpperCase():""}e.isReserved=function(t){var e=(t+"").charCodeAt(0);return 36===e||95===e},e.toString=function(t){return null==t?"":t.toString()},e.toNumber=function(t){return isNaN(t)||null===t||"boolean"==typeof t?t:Number(t)},e.stripQuotes=function(t){var e=t.charCodeAt(0),n=t.charCodeAt(t.length-1);return e!==n||34!==e&&39!==e?!1:t.slice(1,-1)};var r=/-(\w)/g;e.camelize=function(t){return t.replace(r,i)};var s=/(?:^|[-_\/])(\w)/g;e.classify=function(t){return t.replace(s,i)},e.bind=function(t,e){return function(n){var i=arguments.length;return i?i>1?t.apply(e,arguments):t.call(e,n):t.call(e)}},e.toArray=function(t,e){e=e||0;for(var n=t.length-e,i=new Array(n);n--;)i[n]=t[n+e];return i},e.extend=function(t,e){for(var n in e)t[n]=e[n];return t},e.isObject=function(t){return t&&"object"==typeof t};var o=Object.prototype.toString;e.isPlainObject=function(t){return"[object Object]"===o.call(t)},e.isArray=function(t){return Array.isArray(t)},e.define=function(t,e,n,i){Object.defineProperty(t,e,{value:n,enumerable:!!i,writable:!0,configurable:!0})},e.debounce=function(t,e){var n,i,r,s,o,a=function(){var h=Date.now()-s;e>h&&h>=0?n=setTimeout(a,e-h):(n=null,o=t.apply(r,i),n||(r=i=null))};return function(){return r=this,i=arguments,s=Date.now(),n||(n=setTimeout(a,e)),o}},e.indexOf=function(t,e){for(var n=0,i=t.length;i>n;n++)if(t[n]===e)return n;return-1},e.cancellable=function(t){var e=function(){return e.cancelled?void 0:t.apply(this,arguments)};return e.cancel=function(){e.cancelled=!0},e}},function(t,e,n){e.hasProto="__proto__"in{};var i=e.inBrowser="undefined"!=typeof window&&"[object Object]"!==Object.prototype.toString.call(window);if(e.isIE9=i&&navigator.userAgent.toLowerCase().indexOf("msie 9.0")>0,e.isAndroid=i&&navigator.userAgent.toLowerCase().indexOf("android")>0,i&&!e.isIE9){var r=void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend,s=void 0===window.onanimationend&&void 0!==window.onwebkitanimationend;e.transitionProp=r?"WebkitTransition":"transition",e.transitionEndEvent=r?"webkitTransitionEnd":"transitionend",e.animationProp=s?"WebkitAnimation":"animation",e.animationEndEvent=s?"webkitAnimationEnd":"animationend"}e.nextTick=function(){function t(){i=!1;var t=n.slice(0);n=[];for(var e=0;e<t.length;e++)t[e]()}var e,n=[],i=!1;if("undefined"!=typeof MutationObserver){var r=1,s=new MutationObserver(t),o=document.createTextNode(r);s.observe(o,{characterData:!0}),e=function(){r=(r+1)%2,o.data=r}}else e=setTimeout;return function(r,s){var o=s?function(){r.call(s)}:r;n.push(o),i||(i=!0,e(t,0))}}()},function(t,e,n){var i=n(4),r="undefined"!=typeof document&&document.documentElement;e.inDoc=function(t){var e=t&&t.parentNode;return r===t||r===e||!(!e||1!==e.nodeType||!r.contains(e))},e.attr=function(t,e){e=i.prefix+e;var n=t.getAttribute(e);return null!==n&&t.removeAttribute(e),n},e.before=function(t,e){e.parentNode.insertBefore(t,e)},e.after=function(t,n){n.nextSibling?e.before(t,n.nextSibling):n.parentNode.appendChild(t)},e.remove=function(t){t.parentNode.removeChild(t)},e.prepend=function(t,n){n.firstChild?e.before(t,n.firstChild):n.appendChild(t)},e.replace=function(t,e){var n=t.parentNode;n&&n.replaceChild(e,t)},e.on=function(t,e,n){t.addEventListener(e,n)},e.off=function(t,e,n){t.removeEventListener(e,n)},e.addClass=function(t,e){if(t.classList)t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}},e.removeClass=function(t,e){if(t.classList)t.classList.remove(e);else{for(var n=" "+(t.getAttribute("class")||"")+" ",i=" "+e+" ";n.indexOf(i)>=0;)n=n.replace(i," ");t.setAttribute("class",n.trim())}},e.extractContent=function(t,e){var n,i;if("TEMPLATE"===t.tagName&&t.content instanceof DocumentFragment&&(t=t.content),t.hasChildNodes())for(i=e?document.createDocumentFragment():document.createElement("div");n=t.firstChild;)i.appendChild(n);return i}},function(t,e,n){n(4)},function(t,e,n){function i(t,e){var n,r,o;for(n in e)r=t[n],o=e[n],t.hasOwnProperty(n)?s.isObject(r)&&s.isObject(o)&&i(r,o):t.$add(n,o);return t}function r(t){if(t){var e;for(var n in t)e=t[n],s.isPlainObject(e)&&(e.name=n,t[n]=s.Vue.extend(e))}}var s=n(2),o=s.extend,a=Object.create(null);a.data=function(t,e,n){if(n){var r="function"==typeof e?e.call(n):e,s="function"==typeof t?t.call(n):void 0;return r?i(r,s):s}return e?"function"!=typeof e?t:t?function(){return i(e.call(this),t.call(this))}:e:t},a.el=function(t,e,n){if(n||!e||"function"==typeof e){var i=e||t;return n&&"function"==typeof i?i.call(n):i}},a.created=a.ready=a.attached=a.detached=a.beforeCompile=a.compiled=a.beforeDestroy=a.destroyed=a.props=function(t,e){return e?t?t.concat(e):s.isArray(e)?e:[e]:t},a.paramAttributes=function(){},a.directives=a.filters=a.transitions=a.components=a.elementDirectives=function(t,e){var n=Object.create(t);return e?o(n,e):n},a.watch=a.events=function(t,e){if(!e)return t;if(!t)return e;var n={};o(n,t);for(var i in e){var r=n[i],a=e[i];r&&!s.isArray(r)&&(r=[r]),n[i]=r?r.concat(a):[a]}return n},a.methods=a.computed=function(t,e){if(!e)return t;if(!t)return e;var n=Object.create(t);return o(n,e),n};var h=function(t,e){return void 0===e?t:e};e.mergeOptions=function c(t,e,n){function i(i){var r=a[i]||h;o[i]=r(t[i],e[i],n,i)}r(e.components);var s,o={};if(e.mixins)for(var l=0,u=e.mixins.length;u>l;l++)t=c(t,e.mixins[l],n);for(s in t)i(s);for(s in e)t.hasOwnProperty(s)||i(s);return o},e.resolveAsset=function(t,e,n){for(var i=t[e][n];!i&&t._parent;)t=t._parent.$options,i=t[e][n];return i}},function(t,e,n){function i(t,e,n,i,r,s){this.name=t,this.el=e,this.vm=n,this.raw=i.raw,this.expression=i.expression,this.arg=i.arg,this.filters=i.filters,this._descriptor=i,this._host=s,this._locked=!1,this._bound=!1,this._bind(r)}var r=n(2),s=n(4),o=n(11),a=n(20),h=n(16),c=i.prototype;c._bind=function(t){if("cloak"!==this.name&&this.el&&this.el.removeAttribute&&this.el.removeAttribute(s.prefix+this.name),"function"==typeof t?this.update=t:r.extend(this,t),this._watcherExp=this.expression,this._checkDynamicLiteral(),this.bind&&this.bind(),this._watcherExp&&(this.update||this.twoWay)&&(!this.isLiteral||this._isDynamicLiteral)&&!this._checkStatement()){var e=this,n=this._update=this.update?function(t,n){e._locked||e.update(t,n)}:function(){},i=this._preProcess?r.bind(this._preProcess,this):null,a=this._watcher=new o(this.vm,this._watcherExp,n,{filters:this.filters,twoWay:this.twoWay,deep:this.deep,preProcess:i});null!=this._initValue?a.set(this._initValue):this.update&&this.update(a.value)}this._bound=!0},c._checkDynamicLiteral=function(){var t=this.expression;if(t&&this.isLiteral){var e=a.parse(t);if(e){var n=a.tokensToExp(e);this.expression=this.vm.$get(n),this._watcherExp=n,this._isDynamicLiteral=!0}}},c._checkStatement=function(){var t=this.expression;if(t&&this.acceptStatement&&!h.isSimplePath(t)){var e=h.parse(t).get,n=this.vm,i=function(){e.call(n,n)};return this.filters&&(i=n._applyFilters(i,null,this.filters)),this.update(i),!0}},c._checkParam=function(t){var e=this.el.getAttribute(t);return null!==e&&this.el.removeAttribute(t),e},c._teardown=function(){this._bound&&(this._bound=!1,this.unbind&&this.unbind(),this._watcher&&this._watcher.teardown(),this.vm=this.el=this._watcher=null)},c.set=function(t){this.twoWay&&this._withLock(function(){this._watcher.set(t)})},c._withLock=function(t){var e=this;e._locked=!0,t.call(e),r.nextTick(function(){e._locked=!1})},t.exports=i},function(t,e,n){function i(t,e,n,i){this.vm=t,t._watchers.push(this),this.expression=e,this.cb=n,this.id=++l,this.active=!0,i=i||{},this.deep=!!i.deep,this.user=!!i.user,this.twoWay=!!i.twoWay,this.filters=i.filters,this.preProcess=i.preProcess,this.deps=[],this.newDeps=[];var r=h.parse(e,i.twoWay);this.getter=r.get,this.setter=r.set,this.value=this.get()}function r(t){var e,n,i;for(e in t)if(n=t[e],s.isArray(n))for(i=n.length;i--;)r(n[i]);else s.isObject(n)&&r(n)}var s=n(2),o=n(4),a=n(12),h=n(16),c=n(19),l=0,u=i.prototype;u.addDep=function(t){var e=this.newDeps,n=this.deps;if(s.indexOf(e,t)<0){e.push(t);var i=s.indexOf(n,t);0>i?t.addSub(this):n[i]=null}},u.get=function(){this.beforeGet();var t,e=this.vm;try{t=this.getter.call(e,e)}catch(n){o.warnExpressionErrors}return this.deep&&r(t),this.preProcess&&(t=this.preProcess(t)),this.filters&&(t=e._applyFilters(t,null,this.filters,!1)),this.afterGet(),t},u.set=function(t){var e=this.vm;this.filters&&(t=e._applyFilters(t,this.value,this.filters,!0));try{this.setter.call(e,e,t)}catch(n){o.warnExpressionErrors}},u.beforeGet=function(){a.target=this},u.afterGet=function(){a.target=null;for(var t=this.deps.length;t--;){var e=this.deps[t];e&&e.removeSub(this)}this.deps=this.newDeps,this.newDeps=[]},u.update=function(){!o.async||o.debug?this.run():c.push(this)},u.run=function(){if(this.active){var t=this.get();if(t!==this.value||Array.isArray(t)||this.deep){var e=this.value;this.value=t,this.cb(t,e)}}},u.teardown=function(){if(this.active){this.vm._isBeingDestroyed||this.vm._watchers.$remove(this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1,this.vm=this.cb=this.value=null}},t.exports=i},function(t,e,n){function i(t,e){t.__proto__=e}function r(t,e,n){for(var i,r=n.length;r--;)i=n[r],o.define(t,i,e[i])}function s(t,e){if(this.id=++u,this.value=t,this.active=!0,this.deps=[],o.define(t,"__ob__",this),e===f){var n=a.proto&&o.hasProto?i:r;n(t,c,l),this.observeArray(t)}else e===d&&this.walk(t)}var o=n(2),a=n(4),h=n(13),c=n(14),l=Object.getOwnPropertyNames(c);n(15);var u=0,f=0,d=1;s.target=null;var p=s.prototype;s.create=function(t){return t&&t.hasOwnProperty("__ob__")&&t.__ob__ instanceof s?t.__ob__:o.isArray(t)?new s(t,f):o.isPlainObject(t)&&!t._isVue?new s(t,d):void 0},p.walk=function(t){for(var e,n,i=Object.keys(t),r=i.length;r--;)e=i[r],n=e.charCodeAt(0),36!==n&&95!==n&&this.convert(e,t[e])},p.observe=function(t){return s.create(t)},p.observeArray=function(t){for(var e=t.length;e--;)this.observe(t[e])},p.convert=function(t,e){var n=this,i=n.observe(e),r=new h;i&&i.deps.push(r),Object.defineProperty(n.value,t,{enumerable:!0,configurable:!0,get:function(){return n.active&&s.target&&s.target.addDep(r),e},set:function(t){if(t!==e){var i=e&&e.__ob__;i&&i.deps.$remove(r),e=t;var s=n.observe(t);s&&s.deps.push(r),r.notify()}}})},p.notify=function(){for(var t=this.deps,e=0,n=t.length;n>e;e++)t[e].notify()},p.addVm=function(t){(this.vms=this.vms||[]).push(t)},p.removeVm=function(t){this.vms.$remove(t)},t.exports=s},function(t,e,n){function i(){this.subs=[]}var r=n(2),s=i.prototype;s.addSub=function(t){this.subs.push(t)},s.removeSub=function(t){this.subs.$remove(t)},s.notify=function(){for(var t=r.toArray(this.subs),e=0,n=t.length;n>e;e++)t[e].update()},t.exports=i},function(t,e,n){var i=n(2),r=Array.prototype,s=Object.create(r);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=r[t];i.define(s,t,function(){for(var n=arguments.length,i=new Array(n);n--;)i[n]=arguments[n];var r,s=e.apply(this,i),o=this.__ob__;switch(t){case"push":r=i;break;case"unshift":r=i;break;case"splice":r=i.slice(2)}return r&&o.observeArray(r),o.notify(),s})}),i.define(r,"$set",function(t,e){return t>=this.length&&(this.length=t+1),this.splice(t,1,e)[0]}),i.define(r,"$remove",function(t){this.length&&("number"!=typeof t&&(t=i.indexOf(this,t)),t>-1&&this.splice(t,1))}),t.exports=s},function(t,e,n){var i=n(2),r=Object.prototype;i.define(r,"$add",function(t,e){if(!this.hasOwnProperty(t)){var n=this.__ob__;if(!n||i.isReserved(t))return void(this[t]=e);if(n.convert(t,e),n.notify(),n.vms)for(var r=n.vms.length;r--;){var s=n.vms[r];s._proxy(t),s._digest()}}}),i.define(r,"$set",function(t,e){this.$add(t,e),this[t]=e}),i.define(r,"$delete",function(t){if(this.hasOwnProperty(t)){delete this[t];var e=this.__ob__;if(e&&!i.isReserved(t)&&(e.notify(),e.vms))for(var n=e.vms.length;n--;){var r=e.vms[n];r._unproxy(t),r._digest()}}})},function(t,e,n){function i(t,e){var n=x.length;return x[n]=e?t.replace(b,"\\n"):t,'"'+n+'"'}function r(t){var e=t.charAt(0),n=t.slice(1);return v.test(n)?t:(n=n.indexOf('"')>-1?n.replace(C,s):n,e+"scope."+n)}function s(t,e){return x[e]}function o(t,e){_.test(t),x.length=0;var n=t.replace(y,i).replace(g,"");n=(" "+n).replace(w,r).replace(C,s);var o=h(n);return o?{get:o,body:n,set:e?c(n):null}:void 0}function a(t){var e,n;return t.indexOf("[")<0?(n=t.split("."),n.raw=t,e=u.compileGetter(n)):(n=u.parse(t),e=n.get),{get:e,set:function(t,e){u.set(t,n,e)}}}function h(t){try{return new Function("scope","return "+t+";")}catch(e){}}function c(t){try{return new Function("scope","value",t+"=value;")}catch(e){}}function l(t){t.set||(t.set=c(t.body))}var u=(n(2),n(17)),f=n(18),d=new f(1e3),p="Math,Date,this,true,false,null,undefined,Infinity,NaN,isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,parseInt,parseFloat",v=new RegExp("^("+p.replace(/,/g,"\\b|")+"\\b)"),m="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,proctected,static,interface,private,public",_=new RegExp("^("+m.replace(/,/g,"\\b|")+"\\b)"),g=/\s/g,b=/\n/g,y=/[\{,]\s*[\w\$_]+\s*:|('[^']*'|"[^"]*")|new |typeof |void /g,C=/"(\d+)"/g,$=/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/,w=/[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g,k=/^(true|false)$/,x=[];e.parse=function(t,n){t=t.trim();var i=d.get(t);if(i)return n&&l(i),i;var r=e.isSimplePath(t)?a(t):o(t,n);return d.put(t,r),r},e.isSimplePath=function(t){return $.test(t)&&!k.test(t)&&"Math."!==t.slice(0,5)}},function(t,e,n){function i(){}function r(t){if(void 0===t)return"eof";var e=t.charCodeAt(0);switch(e){case 91:case 93:case 46:case 34:case 39:case 48:return t;case 95:case 36:return"ident";case 32:case 9:case 10:case 13:case 160:case 65279:case 8232:case 8233:return"ws"}return e>=97&&122>=e||e>=65&&90>=e?"ident":e>=49&&57>=e?"number":"else"}function s(t){function e(){var e=t[d+1];return"inSingleQuote"===p&&"'"===e||"inDoubleQuote"===p&&'"'===e?(d++,s=e,v.append(),!0):void 0}for(var n,s,o,a,h,c,l,u=[],d=-1,p="beforePath",v={push:function(){void 0!==o&&(u.push(o),o=void 0)},append:function(){void 0===o?o=s:o+=s}};p;)if(d++,n=t[d],"\\"!==n||!e()){if(a=r(n),l=f[p],h=l[a]||l["else"]||"error","error"===h)return;if(p=h[0],c=v[h[1]]||i,s=h[2],s=void 0===s?n:"*"===s?s+n:s,c(),"afterPath"===p)return u.raw=t,u}}function o(t){return u.test(t)?"."+t:+t===t>>>0?"["+t+"]":"*"===t.charAt(0)?"[o"+o(t.slice(1))+"]":'["'+t.replace(/"/g,'\\"')+'"]'}function a(t){}var h=n(2),c=n(18),l=new c(1e3),u=e.identRE=/^[$_a-zA-Z]+[\w$]*$/,f={beforePath:{ws:["beforePath"],ident:["inIdent","append"],"[":["beforeElement"],eof:["afterPath"]},inPath:{ws:["inPath"],".":["beforeIdent"],"[":["beforeElement"],eof:["afterPath"]},beforeIdent:{ws:["beforeIdent"],ident:["inIdent","append"]},inIdent:{ident:["inIdent","append"],0:["inIdent","append"],number:["inIdent","append"],ws:["inPath","push"],".":["beforeIdent","push"],"[":["beforeElement","push"],eof:["afterPath","push"],"]":["inPath","push"]},beforeElement:{ws:["beforeElement"],0:["afterZero","append"],number:["inIndex","append"],"'":["inSingleQuote","append",""],'"':["inDoubleQuote","append",""],ident:["inIdent","append","*"]},afterZero:{ws:["afterElement","push"],"]":["inPath","push"]},inIndex:{0:["inIndex","append"],number:["inIndex","append"],ws:["afterElement"],"]":["inPath","push"]},inSingleQuote:{"'":["afterElement"],eof:"error","else":["inSingleQuote","append"]},inDoubleQuote:{'"':["afterElement"],eof:"error","else":["inDoubleQuote","append"]},afterElement:{ws:["afterElement"],"]":["inPath","push"]}};e.compileGetter=function(t){var e="return o"+t.map(o).join("");return new Function("o","try {"+e+"} catch (e) {}")},e.parse=function(t){var n=l.get(t);return n||(n=s(t),n&&(n.get=e.compileGetter(n),l.put(t,n))),n},e.get=function(t,n){return n=e.parse(n),n?n.get(t):void 0},e.set=function(t,n,i){var r=t;if("string"==typeof n&&(n=e.parse(n)),!n||!h.isObject(t))return!1;for(var s,o,c=0,l=n.length;l>c;c++)s=t,o=n[c],"*"===o.charAt(0)&&(o=r[o.slice(1)]),l-1>c?(t=t[o],h.isObject(t)||(t={},s.$add(o,t),a(n))):o in t?t[o]=i:(t.$add(o,i),a(n));return!0}},function(t,e,n){function i(t){this.size=0,this.limit=t,this.head=this.tail=void 0,this._keymap={}}var r=i.prototype;r.put=function(t,e){var n={key:t,value:e};return this._keymap[t]=n,this.tail?(this.tail.newer=n,n.older=this.tail):this.head=n,this.tail=n,this.size===this.limit?this.shift():void this.size++},r.shift=function(){var t=this.head;return t&&(this.head=this.head.newer,this.head.older=void 0,t.newer=t.older=void 0,this._keymap[t.key]=void 0),t},r.get=function(t,e){var n=this._keymap[t];if(void 0!==n)return n===this.tail?e?n:n.value:(n.newer&&(n===this.head&&(this.head=n.newer),n.newer.older=n.older),n.older&&(n.older.newer=n.newer),n.newer=void 0,n.older=this.tail,this.tail&&(this.tail.newer=n),this.tail=n,e?n:n.value)},t.exports=i},function(t,e,n){function i(){h=[],c=[],l={},u=!1,f=!1}function r(){f=!0,s(h),s(c),i()}function s(t){for(var e=0;e<t.length;e++)t[e].run()}var o=n(2),a=10,h=[],c=[],l={},u=!1,f=!1;e.push=function(t){var e=t.id;if(!e||!l[e]||f){if(l[e]){if(l[e]++,l[e]>a)return}else l[e]=1;if(f&&!t.user)return void t.run();(t.user?c:h).push(t),u||(u=!0,o.nextTick(r))}}},function(t,e,n){function i(t){return t.replace(v,"\\$&")}function r(){d._delimitersChanged=!1;var t=d.delimiters[0],e=d.delimiters[1];l=t.charAt(0),u=e.charAt(e.length-1);var n=i(l),r=i(u),s=i(t),o=i(e);h=new RegExp(n+"?"+s+"(.+?)"+o+r+"?","g"),c=new RegExp("^"+n+s+".*"+o+r+"$"),a=new f(1e3)}function s(t,e,n){return t.tag?e&&t.oneTime?'"'+e.$eval(t.value)+'"':o(t.value,n):'"'+t.value+'"'}function o(t,e){if(m.test(t)){var n=p.parse(t)[0];return n.filters?"this._applyFilters("+n.expression+",null,"+JSON.stringify(n.filters)+",false)":"("+t+")"}return e?t:"("+t+")"}var a,h,c,l,u,f=n(18),d=n(4),p=n(21),v=/[-.*+?^${}()|[\]\/\\]/g;e.parse=function(t){d._delimitersChanged&&r();var e=a.get(t);if(e)return e;if(!h.test(t))return null;for(var n,i,s,o,l,u=[],f=h.lastIndex=0;n=h.exec(t);)i=n.index,i>f&&u.push({value:t.slice(f,i)}),o=n[1].charCodeAt(0),l=42===o,s=l?n[1].slice(1):n[1],u.push({tag:!0,value:s.trim(),html:c.test(n[0]),oneTime:l}),f=i+n[0].length;return f<t.length&&u.push({value:t.slice(f)}),a.put(t,u),u},e.tokensToExp=function(t,e){return t.length>1?t.map(function(t){return s(t,e)}).join("+"):s(t[0],e,!0)};var m=/[^|]\|[^|]/},function(t,e,n){function i(){g.raw=o.slice(v,h).trim(),void 0===g.expression?g.expression=o.slice(m,h).trim():b!==v&&r(),(0===h||g.expression)&&_.push(g)}function r(){var t,e=o.slice(b,h).trim();if(e){t={};var n=e.match(x);t.name=n[0],n.length>1&&(t.args=n.slice(1).map(s))}t&&(g.filters=g.filters||[]).push(t),b=h+1}function s(t){var e=A.test(t)?t:C.stripQuotes(t);return{value:e||t,dynamic:!e}}var o,a,h,c,l,u,f,d,p,v,m,_,g,b,y,C=n(2),$=n(18),w=new $(1e3),k=/^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/,x=/[^\s'"]+|'[^']+'|"[^"]+"/g,A=/^in$|^-?\d+/;e.parse=function(t){var e=w.get(t);if(e)return e;for(o=t,l=u=!1,f=d=p=v=m=0,b=0,_=[],g={},y=null,h=0,c=o.length;c>h;h++)if(a=o.charCodeAt(h),l)39===a&&(l=!l);else if(u)34===a&&(u=!u);else if(44!==a||p||f||d)if(58!==a||g.expression||g.arg)if(124===a&&124!==o.charCodeAt(h+1)&&124!==o.charCodeAt(h-1))void 0===g.expression?(b=h+1,g.expression=o.slice(m,h).trim()):r();else switch(a){case 34:u=!0;break;case 39:l=!0;break;case 40:p++;break;case 41:p--;break;case 91:d++;break;case 93:d--;break;case 123:f++;break;case 125:f--}else y=o.slice(v,h).trim(),k.test(y)&&(m=h+1,g.arg=C.stripQuotes(y)||y);else i(),g={},v=m=b=h+1;return(0===h||v!==h)&&i(),w.put(t,_),_}},function(t,e,n){function i(t,e,n,i){function a(t,e){var n=t._directives.length,s=t.$parent&&t.$parent._directives.length,o=A.toArray(e.childNodes),a=i?t.$parent:t,l=i?t:void 0;h&&h(a,e,l),c&&c(a,o,l);var u=t._directives.slice(n),f=t.$parent&&t.$parent._directives.slice(s);return function(e){r(t,u,e),f&&r(t.$parent,f)}}var h=n?o(t,e):s(t,e),c=h&&h.terminal||"SCRIPT"===t.tagName||!t.hasChildNodes()?null:u(t.childNodes,e);return i&&(a.terminal=!0),a}function r(t,e,n){for(var i=e.length;i--;)e[i]._teardown(),n||t._directives.$remove(e[i])}function s(t,e){var n,i,r,s=e._containerAttrs,o=e._replacerAttrs,a=e.props;return n=a&&s?d(t,s,a):null,11!==t.nodeType&&(e._asComponent?(s&&(i=y(s,e)),o&&(r=y(o,e))):r=y(t,e)),function(t,e,s){n&&n(t,null),i&&i(t.$parent,e,s),r&&r(t,e,s)}}function o(t,e){var n=t.nodeType;return 1===n&&"SCRIPT"!==t.tagName?a(t,e):3===n&&E.interpolate&&t.data.trim()?h(t,e):null}function a(t,e){var n=t.hasAttributes();if(n&&x(t))return t.hasAttribute("__vue__wrap")&&(t=t.firstChild),i(t,e._parent.$options,!0,!0);var r=v(t,e);if(!r&&n&&(r=_(t,e)),r||(r=m(t,e)),!r&&n&&(r=y(t,e)),"TEXTAREA"===t.tagName){var s=r;r=function(t,e){e.value=t.$interpolate(e.value),s&&s(t,e)},r.terminal=!0}return r}function h(t,e){var n=T.parse(t.data);if(!n)return null;for(var i,r,s=document.createDocumentFragment(),o=0,a=n.length;a>o;o++)r=n[o],i=r.tag?c(r,e):document.createTextNode(r.value),s.appendChild(i);return l(n,s,e)}function c(t,e){function n(n){t.type=n,t.def=N(e,"directives",n),t.descriptor=D.parse(t.value)[0]}var i;return t.oneTime?i=document.createTextNode(t.value):t.html?(i=document.createComment("v-html"),n("html")):(i=document.createTextNode(" "),n("text")),i}function l(t,e){return function(n,i){for(var r,s,o,a=e.cloneNode(!0),h=A.toArray(a.childNodes),c=0,l=t.length;l>c;c++)r=t[c],s=r.value,r.tag&&(o=h[c],r.oneTime?(s=n.$eval(s),r.html?A.replace(o,P.parse(s,!0)):o.data=s):n._bindDir(r.type,o,r.descriptor,r.def));A.replace(i,a)}}function u(t,e){for(var n,i,r,s=[],a=0,h=t.length;h>a;a++)r=t[a],n=o(r,e),i=n&&n.terminal||"SCRIPT"===r.tagName||!r.hasChildNodes()?null:u(r.childNodes,e),s.push(n,i);return s.length?f(s):null}function f(t){return function(e,n,i){for(var r,s,o,a=0,h=0,c=t.length;c>a;h++){r=n[h],s=t[a++],o=t[a++];var l=A.toArray(r.childNodes);s&&s(e,r,i),o&&o(e,l,i)}}}function d(t,e,n){for(var i,r,s,o=[],a=n.length;a--;)if(i=n[a],/[A-Z]/.test(i),r=e[i],null!=r){s={name:i,raw:r};var h=T.parse(r);h&&(t&&1===t.nodeType&&t.removeAttribute(i),e[i]=null,s.dynamic=!0,s.value=T.tokensToExp(h),s.oneTime=h.length>1||h[0].oneTime||!I.test(s.value)),o.push(s)}return p(o)}function p(t){return function(e,n){for(var i,r,s=t.length;s--;)i=t[s],r=A.camelize(i.name.replace(V,"")),i.dynamic?e.$parent&&e._bindDir("prop",n,{arg:r,expression:i.value,oneWay:i.oneTime},S):e.$set(r,i.raw)}}function v(t,e){var n=t.tagName.toLowerCase(),i=N(e,"elementDirectives",n);return i?b(t,n,"",e,i):void 0}function m(t,e){var n=A.checkComponent(t,e);if(n){var i=function(t,e,i){t._bindDir("component",e,{expression:n},O,i)};return i.terminal=!0,i}}function _(t,e){if(null!==A.attr(t,"pre"))return g;for(var n,i,r=0,s=j.length;s>r;r++)if(i=j[r],null!==(n=A.attr(t,i)))return b(t,i,n,e)}function g(){}function b(t,e,n,i,r){var s=D.parse(n)[0];r=r||i.directives[e];var o=function(t,n,i){t._bindDir(e,n,s,r,i)};return o.terminal=!0,o}function y(t,e){for(var n,i,r,s,o,a,h=A.isPlainObject(t)?C(t):t.attributes,c=h.length,l=[];c--;)n=h[c],i=n.name,r=n.value,null!==r&&(0===i.indexOf(E.prefix)?(o=i.slice(E.prefix.length),a=N(e,"directives",o),a&&l.push({name:o,descriptors:D.parse(r),def:a})):E.interpolate&&(s=w(i,r,e),s&&l.push(s)));return l.length?(l.sort(k),$(l)):void 0}function C(t){var e=[];for(var n in t)e.push({name:n,value:t[n]});return e}function $(t){return function(e,n,i){for(var r,s,o,a=t.length;a--;)if(r=t[a],r._link)r._link(e,n);else for(o=r.descriptors.length,s=0;o>s;s++)e._bindDir(r.name,n,r.descriptors[s],r.def,i)}}function w(t,e,n){var i=T.parse(e);if(i){for(var r=n.directives.attr,s=i.length,o=!0;s--;){var a=i[s];a.tag&&!a.oneTime&&(o=!1)}return{def:r,_link:o?function(n,i){i.setAttribute(t,n.$interpolate(e))}:function(e,n){var s=T.tokensToExp(i,e),o=D.parse(t+":"+s)[0];e._bindDir("attr",n,o,r)}}}}function k(t,e){return t=t.def.priority||0,e=e.def.priority||0,t>e?1:-1}function x(t){return 1===t.nodeType&&t.hasAttribute(F)?(t.removeAttribute(F),!0):void 0}var A=n(2),E=n(4),T=n(20),D=n(21),P=n(23),N=A.resolveAsset,S=n(24),O=n(25),j=["repeat","if"];t.exports=i;var I=/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]\])*$/,V=/^data-/;g.terminal=!0;var F="__vue__transcluded"},function(t,e,n){function i(t){var e=a.get(t);if(e)return e;var n=document.createDocumentFragment(),i=t.match(l),r=u.test(t);if(i||r){var s=i&&i[1],o=c[s]||c._default,h=o[0],f=o[1],d=o[2],p=document.createElement("div");for(p.innerHTML=f+t.trim()+d;h--;)p=p.lastChild;for(var v;v=p.firstChild;)n.appendChild(v)}else n.appendChild(document.createTextNode(t));return a.put(t,n),n}function r(t){var n=t.tagName;if("TEMPLATE"===n&&t.content instanceof DocumentFragment)return t.content;if("SCRIPT"===n)return i(t.textContent);for(var r,s=e.clone(t),o=document.createDocumentFragment();r=s.firstChild;)o.appendChild(r);return o}var s=n(2),o=n(18),a=new o(1e3),h=new o(1e3),c={_default:[0,"",""],legend:[1,"<fieldset>","</fieldset>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"]};c.td=c.th=[3,"<table><tbody><tr>","</tr></tbody></table>"],c.option=c.optgroup=[1,'<select multiple="multiple">',"</select>"],c.thead=c.tbody=c.colgroup=c.caption=c.tfoot=[1,"<table>","</table>"],c.g=c.defs=c.symbol=c.use=c.image=c.text=c.circle=c.ellipse=c.line=c.path=c.polygon=c.polyline=c.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>"];var l=/<([\w:]+)/,u=/&\w+;/,f=s.inBrowser?function(){var t=document.createElement("div");return t.innerHTML="<template>1</template>",!t.cloneNode(!0).firstChild.innerHTML}():!1,d=s.inBrowser?function(){var t=document.createElement("textarea");return t.placeholder="t","t"===t.cloneNode(!0).value}():!1;e.clone=function(t){var e,n,i,r=t.cloneNode(!0);if(f&&(n=t.querySelectorAll("template"),n.length))for(i=r.querySelectorAll("template"),e=i.length;e--;)i[e].parentNode.replaceChild(n[e].cloneNode(!0),i[e]);if(d)if("TEXTAREA"===t.tagName)r.value=t.value;else if(n=t.querySelectorAll("textarea"),n.length)for(i=r.querySelectorAll("textarea"),e=i.length;e--;)i[e].value=n[e].value;return r},e.parse=function(t,n,s){var o,a;return t instanceof DocumentFragment?n?t.cloneNode(!0):t:("string"==typeof t?s||"#"!==t.charAt(0)?a=i(t):(a=h.get(t),a||(o=document.getElementById(t.slice(1)),o&&(a=r(o),h.put(t,a)))):t.nodeType&&(a=r(t)),a&&n?e.clone(a):a)}},function(t,e,n){var i=n(2),r=n(11),s=n(17).identRE;t.exports={bind:function(){var t=this.vm,e=t.$parent,n=this.arg,o=this.expression;!s.test(n);var a=!1,h=function(){a=!0,i.nextTick(c)},c=function(){a=!1};this.parentWatcher=new r(e,o,function(e){a||(h(),t[n]=e)}),t.$set(n,this.parentWatcher.value),this._descriptor.oneWay||(this.childWatcher=new r(t,n,function(t){a||(h(),e.$set(o,t))}))},unbind:function(){this.parentWatcher&&this.parentWatcher.teardown(),this.childWatcher&&this.childWatcher.teardown()}}},function(t,e,n){var i=n(2),r=n(23);t.exports={isLiteral:!0,bind:function(){this.el.__vue__||(this.anchor=i.createAnchor("v-component"),i.replace(this.el,this.anchor),this.keepAlive=null!=this._checkParam("keep-alive"),this.refID=i.attr(this.el,"ref"),this.keepAlive&&(this.cache={}),null!==this._checkParam("inline-template")&&(this.template=i.extractContent(this.el,!0)),this._pendingCb=this.ctorId=this.Ctor=null,this._isDynamicLiteral?(this.readyEvent=this._checkParam("wait-for"),this.transMode=this._checkParam("transition-mode")):this.resolveCtor(this.expression,i.bind(function(){var t=this.build();t.$before(this.anchor),this.setCurrent(t)},this)))},update:function(t){this.realUpdate(t)},realUpdate:function(t,e){this.invalidatePending(),t?this.resolveCtor(t,i.bind(function(){this.unbuild();var t=this.build(),n=this;this.readyEvent?t.$once(this.readyEvent,function(){n.swapTo(t,e)}):this.swapTo(t,e)},this)):(this.unbuild(),this.remove(this.childVM,e),this.unsetCurrent())},resolveCtor:function(t,e){var n=this;this._pendingCb=i.cancellable(function(i){n.ctorId=t,n.Ctor=i,e()}),this.vm._resolveComponent(t,this._pendingCb)},invalidatePending:function(){this._pendingCb&&(this._pendingCb.cancel(),this._pendingCb=null)},build:function(){if(this.keepAlive){var t=this.cache[this.ctorId];if(t)return t}var e=this.vm,n=r.clone(this.el);if(this.Ctor){var i=e.$addChild({el:n,template:this.template,_asComponent:!0,_host:this._host},this.Ctor);return this.keepAlive&&(this.cache[this.ctorId]=i),i}},unbuild:function(){var t=this.childVM;t&&!this.keepAlive&&t.$destroy(!1,!0)},remove:function(t,e){var n=this.keepAlive;t?t.$remove(function(){n||t._cleanup(),e&&e()}):e&&e()},swapTo:function(t,e){var n=this,i=this.childVM;
+switch(this.unsetCurrent(),this.setCurrent(t),n.transMode){case"in-out":t.$before(n.anchor,function(){n.remove(i,e)});break;case"out-in":n.remove(i,function(){t.$before(n.anchor,e)});break;default:n.remove(i),t.$before(n.anchor,e)}},setCurrent:function(t){this.childVM=t;var e=t._refID||this.refID;e&&(this.vm.$[e]=t)},unsetCurrent:function(){var t=this.childVM;this.childVM=null;var e=t&&t._refID||this.refID;e&&(this.vm.$[e]=null)},unbind:function(){if(this.invalidatePending(),this.unbuild(),this.cache){for(var t in this.cache)this.cache[t].$destroy();this.cache=null}}}},function(t,e,n){function i(t,e){var n=e.template,i=u.parse(n,!0);if(i){var s=e._content||c.extractContent(t),o=i.firstChild;return e.replace?i.childNodes.length>1||1!==o.nodeType||o.hasAttribute(l.prefix+"repeat")?(r(i,s),i):(e._replacerAttrs=a(o),h(t,o),r(o,s),o):(t.appendChild(i),r(t,s),t)}}function r(t,e){function n(t){return t.parentNode===e}var i=s(t),r=i.length;if(r){for(var a,h,l,u,f;r--;)a=i[r],e?(h=a.getAttribute("select"),h?(l=e.querySelectorAll(h),l.length&&(l=[].filter.call(l,n)),a.content=l.length?l:c.toArray(a.childNodes)):f=a):a.content=c.toArray(a.childNodes);for(r=0,u=i.length;u>r;r++)a=i[r],a!==f&&o(a,a.content);f&&o(f,c.toArray(e.childNodes))}}function s(t){return c.isArray(t)?d.apply([],t.map(s)):t.querySelectorAll?c.toArray(t.querySelectorAll("content")):[]}function o(t,e){for(var n=t.parentNode,i=0,r=e.length;r>i;i++)n.insertBefore(e[i],t);n.removeChild(t)}function a(t){if(1===t.nodeType&&t.hasAttributes()){for(var e=t.attributes,n={},i=e.length;i--;)n[e[i].name]=e[i].value;return n}}function h(t,e){for(var n,i,r=t.attributes,s=r.length;s--;)n=r[s].name,i=r[s].value,e.hasAttribute(n)?"class"===n&&(e.className=e.className+" "+i):e.setAttribute(n,i)}var c=n(2),l=n(4),u=n(23),f="__vue__transcluded";t.exports=function(t,e){if(e&&(e._containerAttrs=a(t)),e&&e._asComponent)for(var n=t.childNodes.length;n--;){var r=t.childNodes[n];if(1===r.nodeType)r.setAttribute(f,"");else if(3===r.nodeType&&r.data.trim()){var s=document.createElement("span");s.textContent=r.data,s.setAttribute("__vue__wrap",""),s.setAttribute(f,""),t.replaceChild(s,r)}}return"TEMPLATE"===t.tagName&&(t=u.parse(t)),e&&e.template&&(t=i(t,e)),t instanceof DocumentFragment&&(c.prepend(c.createAnchor("v-start",!0),t),t.appendChild(c.createAnchor("v-end",!0))),t};var d=[].concat},function(t,e,n){function i(t){return new Function("return function "+s.classify(t)+" (options) { this._init(options) }")()}function r(t){o._assetTypes.forEach(function(e){t[e]=function(t,n){return n?void(this.options[e+"s"][t]=n):this.options[e+"s"][t]}}),t.component=function(t,e){return e?(s.isPlainObject(e)&&(e.name=t,e=s.Vue.extend(e)),void(this.options.components[t]=e)):this.options.components[t]}}var s=n(2),o=n(4);e.util=s,e.nextTick=s.nextTick,e.config=n(4),e.compiler={compile:n(22),transclude:n(26)},e.parsers={path:n(17),text:n(20),template:n(23),directive:n(21),expression:n(16)},e.cid=0;var a=1;e.extend=function(t){t=t||{};var e=this,n=i(t.name||e.options.name||"VueComponent");return n.prototype=Object.create(e.prototype),n.prototype.constructor=n,n.cid=a++,n.options=s.mergeOptions(e.options,t),n["super"]=e,n.extend=e.extend,r(n),n},e.use=function(t){var e=s.toArray(arguments,1);return e.unshift(this),"function"==typeof t.install?t.install.apply(t,e):t.apply(null,e),this},r(e)},function(t,e,n){e.text=n(29),e.html=n(30),e.attr=n(31),e.show=n(32),e["class"]=n(34),e.el=n(35),e.ref=n(36),e.cloak=n(37),e.style=n(38),e.transition=n(39),e.on=n(42),e.model=n(43),e.repeat=n(48),e["if"]=n(49),e.events=n(50),e._component=n(25),e._prop=n(24)},function(t,e,n){var i=n(2);t.exports={bind:function(){this.attr=3===this.el.nodeType?"nodeValue":"textContent"},update:function(t){this.el[this.attr]=i.toString(t)}}},function(t,e,n){var i=n(2),r=n(23);t.exports={bind:function(){8===this.el.nodeType&&(this.nodes=[],this.anchor=i.createAnchor("v-html"),i.replace(this.el,this.anchor))},update:function(t){t=i.toString(t),this.nodes?this.swap(t):this.el.innerHTML=t},swap:function(t){for(var e=this.nodes.length;e--;)i.remove(this.nodes[e]);var n=r.parse(t,!0,!0);this.nodes=i.toArray(n.childNodes),i.before(n,this.anchor)}}},function(t,e,n){function i(t){t||0===t?this.el.setAttribute(this.arg,t):this.el.removeAttribute(this.arg)}function r(t){null!=t?this.el.setAttributeNS(s,this.arg,t):this.el.removeAttributeNS(s,"href")}var s="http://www.w3.org/1999/xlink",o=/^xlink:/;t.exports={priority:850,bind:function(){var t=this.arg;this.update=o.test(t)?r:i}}},function(t,e,n){var i=n(33);t.exports=function(t){var e=this.el;i.apply(e,t?1:-1,function(){e.style.display=t?"":"none"},this.vm)}},function(t,e,n){var i=n(2);e.append=function(t,e,n,i){r(t,1,function(){e.appendChild(t)},n,i)},e.before=function(t,e,n,s){r(t,1,function(){i.before(t,e)},n,s)},e.remove=function(t,e,n){r(t,-1,function(){i.remove(t)},e,n)},e.removeThenAppend=function(t,e,n,i){r(t,-1,function(){e.appendChild(t)},n,i)},e.blockAppend=function(t,n,r){for(var s=i.toArray(t.childNodes),o=0,a=s.length;a>o;o++)e.before(s[o],n,r)},e.blockRemove=function(t,n,i){for(var r,s=t.nextSibling;s!==n;)r=s.nextSibling,e.remove(s,i),s=r};var r=e.apply=function(t,e,n,r,s){var o=t.__v_trans;if(!o||!o.hooks&&!i.transitionEndEvent||!r._isCompiled||r.$parent&&!r.$parent._isCompiled)return n(),void(s&&s());var a=e>0?"enter":"leave";o[a](n,s)}},function(t,e,n){var i=n(2),r=i.addClass,s=i.removeClass;t.exports=function(t){if(this.arg){var e=t?r:s;e(this.el,this.arg)}else this.lastVal&&s(this.el,this.lastVal),t&&(r(this.el,t),this.lastVal=t)}},function(t,e,n){t.exports={isLiteral:!0,bind:function(){this.vm.$$[this.expression]=this.el},unbind:function(){delete this.vm.$$[this.expression]}}},function(t,e,n){n(2);t.exports={isLiteral:!0,bind:function(){var t=this.el.__vue__;t&&(t._refID=this.expression)}}},function(t,e,n){var i=n(4);t.exports={bind:function(){var t=this.el;this.vm.$once("hook:compiled",function(){t.removeAttribute(i.prefix+"cloak")})}}},function(t,e,n){function i(t){if(u[t])return u[t];var e=r(t);return u[t]=u[e]=e,e}function r(t){t=t.replace(c,"$1-$2").toLowerCase();var e=s.camelize(t),n=e.charAt(0).toUpperCase()+e.slice(1);if(l||(l=document.createElement("div")),e in l.style)return t;for(var i,r=o.length;r--;)if(i=a[r]+n,i in l.style)return o[r]+t}var s=n(2),o=["-webkit-","-moz-","-ms-"],a=["Webkit","Moz","ms"],h=/!important;?$/,c=/([a-z])([A-Z])/g,l=null,u={};t.exports={deep:!0,update:function(t){if(this.arg)this.setProp(this.arg,t);else if("object"==typeof t){this.cache||(this.cache={});for(var e in t)this.setProp(e,t[e]),t[e]!=this.cache[e]&&(this.cache[e]=t[e],this.setProp(e,t[e]))}else this.el.style.cssText=t},setProp:function(t,e){if(t=i(t))if(null!=e&&(e+=""),e){var n=h.test(e)?"important":"";n&&(e=e.replace(h,"").trim()),this.el.style.setProperty(t,e,n)}else this.el.style.removeProperty(t)}}},function(t,e,n){var i=n(2),r=n(40);t.exports={priority:1e3,isLiteral:!0,bind:function(){this._isDynamicLiteral||this.update(this.expression)},update:function(t,e){var n=this.el,s=this.el.__vue__||this.vm,o=i.resolveAsset(s.$options,"transitions",t);t=t||"v",n.__v_trans=new r(n,t,o,s),e&&i.removeClass(n,e+"-transition"),i.addClass(n,t+"-transition")}}},function(t,e,n){function i(t,e,n,i){this.el=t,this.enterClass=e+"-enter",this.leaveClass=e+"-leave",this.hooks=n,this.vm=i,this.pendingCssEvent=this.pendingCssCb=this.jsCancel=this.pendingJsCb=this.op=this.cb=null,this.typeCache={};var s=this;["enterNextTick","enterDone","leaveNextTick","leaveDone"].forEach(function(t){s[t]=r.bind(s[t],s)})}var r=n(2),s=n(41),o=r.addClass,a=r.removeClass,h=r.transitionEndEvent,c=r.animationEndEvent,l=r.transitionProp+"Duration",u=r.animationProp+"Duration",f="undefined"==typeof document?null:document,d=1,p=2,v=i.prototype;v.enter=function(t,e){this.cancelPending(),this.callHook("beforeEnter"),this.cb=e,o(this.el,this.enterClass),t(),this.callHookWithCb("enter"),s.push(this.enterNextTick)},v.enterNextTick=function(){var t=this.getCssTransitionType(this.enterClass),e=this.enterDone;t===d?(a(this.el,this.enterClass),this.setupCssCb(h,e)):t===p?this.setupCssCb(c,e):this.pendingJsCb||e()},v.enterDone=function(){this.jsCancel=this.pendingJsCb=null,a(this.el,this.enterClass),this.callHook("afterEnter"),this.cb&&this.cb()},v.leave=function(t,e){this.cancelPending(),this.callHook("beforeLeave"),this.op=t,this.cb=e,o(this.el,this.leaveClass),this.callHookWithCb("leave"),this.pendingJsCb||s.push(this.leaveNextTick)},v.leaveNextTick=function(){var t=this.getCssTransitionType(this.leaveClass);if(t){var e=t===d?h:c;this.setupCssCb(e,this.leaveDone)}else this.leaveDone()},v.leaveDone=function(){this.op(),a(this.el,this.leaveClass),this.callHook("afterLeave"),this.cb&&this.cb()},v.cancelPending=function(){this.op=this.cb=null;var t=!1;this.pendingCssCb&&(t=!0,r.off(this.el,this.pendingCssEvent,this.pendingCssCb),this.pendingCssEvent=this.pendingCssCb=null),this.pendingJsCb&&(t=!0,this.pendingJsCb.cancel(),this.pendingJsCb=null),t&&(a(this.el,this.enterClass),a(this.el,this.leaveClass)),this.jsCancel&&(this.jsCancel.call(null),this.jsCancel=null)},v.callHook=function(t){this.hooks&&this.hooks[t]&&this.hooks[t].call(this.vm,this.el)},v.callHookWithCb=function(t){var e=this.hooks&&this.hooks[t];e&&(e.length>1&&(this.pendingJsCb=r.cancellable(this[t+"Done"])),this.jsCancel=e.call(this.vm,this.el,this.pendingJsCb))},v.getCssTransitionType=function(t){if(!(!h||f&&f.hidden)){var e=this.typeCache[t];if(e)return e;var n=this.el.style,i=window.getComputedStyle(this.el),r=n[l]||i[l];if(r&&"0s"!==r)e=d;else{var s=n[u]||i[u];s&&"0s"!==s&&(e=p)}return e&&(this.typeCache[t]=e),e}},v.setupCssCb=function(t,e){this.pendingCssEvent=t;var n=this,i=this.el,s=this.pendingCssCb=function(o){o.target===i&&(r.off(i,t,s),n.pendingCssEvent=n.pendingCssCb=null,!n.pendingJsCb&&e&&e())};r.on(i,t,s)},t.exports=i},function(t,e,n){function i(){for(var t=document.documentElement.offsetHeight,e=0;e<s.length;e++)s[e]();return s=[],o=!1,t}var r=n(2),s=[],o=!1;e.push=function(t){s.push(t),o||(o=!0,r.nextTick(i))}},function(t,e,n){var i=n(2);t.exports={acceptStatement:!0,priority:700,bind:function(){if("IFRAME"===this.el.tagName&&"load"!==this.arg){var t=this;this.iframeBind=function(){i.on(t.el.contentWindow,t.arg,t.handler)},i.on(this.el,"load",this.iframeBind)}},update:function(t){if("function"==typeof t){this.reset();var e=this.vm;this.handler=function(n){n.targetVM=e,e.$event=n;var i=t(n);return e.$event=null,i},this.iframeBind?this.iframeBind():i.on(this.el,this.arg,this.handler)}},reset:function(){var t=this.iframeBind?this.el.contentWindow:this.el;this.handler&&i.off(t,this.arg,this.handler)},unbind:function(){this.reset(),i.off(this.el,"load",this.iframeBind)}}},function(t,e,n){var i=n(2),r={text:n(44),radio:n(45),select:n(46),checkbox:n(47)};t.exports={priority:800,twoWay:!0,handlers:r,bind:function(){this.checkFilters(),this.hasRead&&!this.hasWrite;var t,e=this.el,n=e.tagName;if("INPUT"===n)t=r[e.type]||r.text;else if("SELECT"===n)t=r.select;else{if("TEXTAREA"!==n)return;t=r.text}t.bind.call(this),this.update=t.update,this.unbind=t.unbind},checkFilters:function(){var t=this.filters;if(t)for(var e=t.length;e--;){var n=i.resolveAsset(this.vm.$options,"filters",t[e].name);"function"==typeof n||n.read?this.hasRead=!0:n.write&&(this.hasWrite=!0)}}}},function(t,e,n){var i=n(2);t.exports={bind:function(){function t(){var t=s?i.toNumber(n.value):n.value;e.set(t)}var e=this,n=this.el,r=null!=this._checkParam("lazy"),s=null!=this._checkParam("number"),o=parseInt(this._checkParam("debounce"),10),a=!1;i.isAndroid||(this.onComposeStart=function(){a=!0},this.onComposeEnd=function(){a=!1,e.listener()},i.on(n,"compositionstart",this.onComposeStart),i.on(n,"compositionend",this.onComposeEnd)),this.hasRead||"range"===n.type?this.listener=function(){if(!a){var r;try{r=n.value.length-n.selectionStart}catch(s){}0>r||(t(),i.nextTick(function(){var t=e._watcher.value;if(e.update(t),null!=r){var s=i.toString(t).length-r;n.setSelectionRange(s,s)}}))}}:this.listener=function(){a||t()},o&&(this.listener=i.debounce(this.listener,o)),this.event=r?"change":"input",this.hasjQuery="function"==typeof jQuery,this.hasjQuery?jQuery(n).on(this.event,this.listener):i.on(n,this.event,this.listener),!r&&i.isIE9&&(this.onCut=function(){i.nextTick(e.listener)},this.onDel=function(t){(46===t.keyCode||8===t.keyCode)&&e.listener()},i.on(n,"cut",this.onCut),i.on(n,"keyup",this.onDel)),(n.hasAttribute("value")||"TEXTAREA"===n.tagName&&n.value.trim())&&(this._initValue=s?i.toNumber(n.value):n.value)},update:function(t){this.el.value=i.toString(t)},unbind:function(){var t=this.el;this.hasjQuery?jQuery(t).off(this.event,this.listener):i.off(t,this.event,this.listener),this.onComposeStart&&(i.off(t,"compositionstart",this.onComposeStart),i.off(t,"compositionend",this.onComposeEnd)),this.onCut&&(i.off(t,"cut",this.onCut),i.off(t,"keyup",this.onDel))}}},function(t,e,n){var i=n(2);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.value)},i.on(e,"change",this.listener),e.checked&&(this._initValue=e.value)},update:function(t){this.el.checked=t==this.el.value},unbind:function(){i.off(this.el,"change",this.listener)}}},function(t,e,n){function i(t){function e(t){l.isArray(t)&&(n.el.innerHTML="",r(n.el,t),n._watcher&&n.update(n._watcher.value))}var n=this,i=f.parse(t)[0];this.optionWatcher=new u(this.vm,i.expression,e,{deep:!0,filters:i.filters}),e(this.optionWatcher.value)}function r(t,e){for(var n,i,s=0,o=e.length;o>s;s++)n=e[s],n.options?(i=document.createElement("optgroup"),i.label=n.label,r(i,n.options)):(i=document.createElement("option"),"string"==typeof n?i.text=i.value=n:(null!=n.value&&(i.value=n.value),i.text=n.text||n.value||"",n.disabled&&(i.disabled=!0))),t.appendChild(i)}function s(){for(var t,e=this.el.options,n=0,i=e.length;i>n;n++)e[n].hasAttribute("selected")&&(this.multiple?(t||(t=[])).push(e[n].value):t=e[n].value);"undefined"!=typeof t&&(this._initValue=this.number?l.toNumber(t):t)}function o(t){return Array.prototype.filter.call(t.options,a).map(h)}function a(t){return t.selected}function h(t){return t.value||t.text}function c(t,e){for(var n=t.length;n--;)if(t[n]==e)return n;return-1}var l=n(2),u=n(11),f=n(21);t.exports={bind:function(){var t=this,e=this.el,n=this._checkParam("options");n&&i.call(this,n),this.number=null!=this._checkParam("number"),this.multiple=e.hasAttribute("multiple"),this.listener=function(){var n=t.multiple?o(e):e.value;n=t.number?l.isArray(n)?n.map(l.toNumber):l.toNumber(n):n,t.set(n)},l.on(e,"change",this.listener),s.call(this)},update:function(t){var e=this.el;e.selectedIndex=-1;for(var n,i=this.multiple&&l.isArray(t),r=e.options,s=r.length;s--;)n=r[s],n.selected=i?c(t,n.value)>-1:t==n.value},unbind:function(){l.off(this.el,"change",this.listener),this.optionWatcher&&this.optionWatcher.teardown()}}},function(t,e,n){var i=n(2);t.exports={bind:function(){var t=this,e=this.el;this.listener=function(){t.set(e.checked)},i.on(e,"change",this.listener),e.checked&&(this._initValue=e.checked)},update:function(t){this.el.checked=!!t},unbind:function(){i.off(this.el,"change",this.listener)}}},function(t,e,n){function i(t,e){for(var n=(t._blockEnd||t.$el).nextSibling;!n.__vue__&&n!==e;)n=n.nextSibling;return n.__vue__}function r(t){for(var e=-1,n=new Array(t);++e<t;)n[e]=e;return n}var s=n(2),o=s.isObject,a=s.isPlainObject,h=n(20),c=n(16),l=n(23),u=n(22),f=n(26),d=0,p=0,v=1,m=2,_=3;t.exports={bind:function(){this.id="__v_repeat_"+ ++d,this.anchor=s.createAnchor("v-repeat"),s.replace(this.el,this.anchor),this.template="TEMPLATE"===this.el.tagName?l.parse(this.el,!0):this.el,this.checkIf(),this.checkRef(),this.checkComponent(),this.idKey=this._checkParam("track-by")||this._checkParam("trackby"),this.cache=Object.create(null)},checkIf:function(){null!==s.attr(this.el,"if")},checkRef:function(){var t=s.attr(this.el,"ref");this.refID=t?this.vm.$interpolate(t):null;var e=s.attr(this.el,"el");this.elId=e?this.vm.$interpolate(e):null},checkComponent:function(){this.componentState=p;var t=this.vm.$options,e=s.checkComponent(this.el,t);if(e){this.Ctor=null,this.asComponent=!0,null!==this._checkParam("inline-template")&&(this.inlineTempalte=s.extractContent(this.el,!0));var n=h.parse(e);if(n){var i=h.tokensToExp(n);this.ctorGetter=c.parse(i).get}else this.componentId=e,this.pendingData=null}else{this.Ctor=s.Vue,this.inherit=!0,this.template=f(this.template);var r=s.extend({},t);r._asComponent=!1,this._linkFn=u(this.template,r)}},resolveComponent:function(){this.componentState=v,this.vm._resolveComponent(this.componentId,s.bind(function(t){if(this.componentState!==_){this.Ctor=t;var e=s.mergeOptions(t.options,{},{$parent:this.vm});e.template=this.inlineTempalte||e.template,e._asComponent=!0,e._parent=this.vm,this.template=f(this.template,e),this.template.__vue__=!0,this._linkFn=u(this.template,e),this.componentState=m,this.realUpdate(this.pendingData),this.pendingData=null}},this))},resolveDynamicComponent:function(t,e){var n,i=Object.create(this.vm);for(n in t)s.define(i,n,t[n]);for(n in e)s.define(i,n,e[n]);var r=this.ctorGetter.call(i,i),o=s.resolveAsset(this.vm.$options,"components",r);return o.options?o:s.Vue},update:function(t){if(this.componentId){var e=this.componentState;e===p?(this.pendingData=t,this.resolveComponent()):e===v?this.pendingData=t:e===m&&this.realUpdate(t)}else this.realUpdate(t)},realUpdate:function(t){this.vms=this.diff(t,this.vms),this.refID&&(this.vm.$[this.refID]=this.vms),this.elId&&(this.vm.$$[this.elId]=this.vms.map(function(t){return t.$el}))},diff:function(t,e){var n,r,o,a,h,c=this.idKey,l=this.converted,u=this.anchor,f=this.arg,d=!e,p=new Array(t.length);for(a=0,h=t.length;h>a;a++)n=t[a],r=l?n.$value:n,o=!d&&this.getVm(r,a,l?n.$key:null),o?(o._reused=!0,o.$index=a,(c||l)&&(f?o[f]=r:s.isPlainObject(r)?o.$data=r:o.$value=r)):(o=this.build(n,a,!0),o._new=!d,o._reused=!1),p[a]=o,d&&o.$before(u);if(d)return p;for(a=0,h=e.length;h>a;a++)o=e[a],o._reused||(this.uncacheVm(o),o.$destroy(!0));var v,m;for(a=p.length;a--;){if(o=p[a],v=p[a+1]){var _=v.$el;o._reused?(m=i(o,u),m!==v&&o.$before(_,null,!1)):o.$before(_)}else o._reused||o.$before(u);o._new=!1,o._reused=!1}return p},build:function(t,e,n){var i={$index:e};this.converted&&(i.$key=t.$key);var r=this.converted?t.$value:t,s=this.arg;s?(t={},t[s]=r):a(r)?t=r:(t={},i.$value=r);var o=this.Ctor||this.resolveDynamicComponent(t,i),h=this.vm.$addChild({el:l.clone(this.template),_asComponent:this.asComponent,_host:this._host,_linkFn:this._linkFn,_meta:i,data:t,inherit:this.inherit,template:this.inlineTempalte},o);h._repeat=!0,n&&this.cacheVm(r,h,e,this.converted?i.$key:null);var c=typeof r,u=this;return"object"!==this.rawType||"string"!==c&&"number"!==c||h.$watch(s||"$value",function(t){u._withLock(function(){u.converted?u.rawValue[h.$key]=t:u.rawValue.$set(h.$index,t)})}),h},unbind:function(){if(this.componentState=_,this.refID&&(this.vm.$[this.refID]=null),this.vms)for(var t,e=this.vms.length;e--;)t=this.vms[e],this.uncacheVm(t),t.$destroy()},cacheVm:function(t,e,n,i){var r,a=this.idKey,h=this.cache;i||a?(r=a?"$index"===a?n:t[a]:i,h[r]||(h[r]=e)):o(t)?(r=this.id,t.hasOwnProperty(r)?null===t[r]&&(t[r]=e):s.define(t,r,e)):h[t]?h[t].push(e):h[t]=[e],e._raw=t},getVm:function(t,e,n){var i=this.idKey;if(n||i){var r=i?"$index"===i?e:t[i]:n;return this.cache[r]}if(o(t))return t[this.id];var s=this.cache[t];if(s){for(var a=0,h=s[a];h&&(h._reused||h._new);)h=s[++a];return h}},uncacheVm:function(t){var e=t._raw,n=this.idKey,i=t.$key;if(n||i){var r=n?"$index"===n?t.$index:e[n]:i;this.cache[r]=null}else o(e)?(e[this.id]=null,t._raw=null):this.cache[e].pop()},_preProcess:function(t){this.rawValue=t;var e=this.rawType=typeof t;if(a(t)){for(var n,i=Object.keys(t),o=i.length,h=new Array(o);o--;)n=i[o],h[o]={$key:n,$value:t[n]};return this.converted=!0,h}return this.converted=!1,"number"===e?t=r(t):"string"===e&&(t=s.toArray(t)),t||[]}}},function(t,e,n){function i(t){t._isAttached||t._callHook("attached")}function r(t){t._isAttached&&t._callHook("detached")}var s=n(2),o=n(22),a=n(23),h=n(33);t.exports={bind:function(){var t=this.el;t.__vue__?this.invalid=!0:(this.start=s.createAnchor("v-if-start"),this.end=s.createAnchor("v-if-end"),s.replace(t,this.end),s.before(this.start,this.end),"TEMPLATE"===t.tagName?this.template=a.parse(t,!0):(this.template=document.createDocumentFragment(),this.template.appendChild(a.clone(t))),this.linker=o(this.template,this.vm.$options,!0))},update:function(t){this.invalid||(t?this.unlink||this.compile():this.teardown())},compile:function(){var t=this.vm,e=a.clone(this.template);if(this.unlink=this.linker(t,e),h.blockAppend(e,this.end,t),s.inDoc(t.$el)){var n=this.getContainedComponents();n&&n.forEach(i)}},teardown:function(){if(this.unlink){var t;s.inDoc(this.vm.$el)&&(t=this.getContainedComponents()),h.blockRemove(this.start,this.end,this.vm),t&&t.forEach(r),this.unlink(),this.unlink=null}},getContainedComponents:function(){function t(t){for(var e,r=n;e!==i;){if(e=r.nextSibling,r.contains(t.$el))return!0;r=e}return!1}var e=this.vm,n=this.start.nextSibling,i=this.end,r=e._children.length&&e._children.filter(t),s=e._transCpnts&&e._transCpnts.filter(t);return r?s?r.concat(s):r:s},unbind:function(){this.unlink&&this.unlink()}}},function(t,e,n){n(2);t.exports={acceptStatement:!0,bind:function(){var t=this.el.__vue__;!t||this.vm!==t.$parent},update:function(t,e){if("function"==typeof t){var n=this.el.__vue__;e&&n.$off(this.arg,e),n.$on(this.arg,t)}}}},function(t,e,n){var i=n(2);e.json={read:function(t,e){return"string"==typeof t?t:JSON.stringify(t,null,Number(e)||2)},write:function(t){try{return JSON.parse(t)}catch(e){return t}}},e.capitalize=function(t){return t||0===t?(t=t.toString(),t.charAt(0).toUpperCase()+t.slice(1)):""},e.uppercase=function(t){return t||0===t?t.toString().toUpperCase():""},e.lowercase=function(t){return t||0===t?t.toString().toLowerCase():""};var r=/(\d{3})(?=\d)/g;e.currency=function(t,e){if(t=parseFloat(t),!isFinite(t)||!t&&0!==t)return"";e=e||"$";var n=Math.floor(Math.abs(t)).toString(),i=n.length%3,s=i>0?n.slice(0,i)+(n.length>3?",":""):"",o=Math.abs(parseInt(100*t%100,10)),a="."+(10>o?"0"+o:o);return(0>t?"-":"")+e+s+n.slice(i).replace(r,"$1,")+a},e.pluralize=function(t){var e=i.toArray(arguments,1);return e.length>1?e[t%10-1]||e[e.length-1]:e[0]+(1===t?"":"s")};var s={enter:13,tab:9,"delete":46,up:38,left:37,right:39,down:40,esc:27};e.key=function(t,e){if(t){var n=s[e];return n||(n=parseInt(e,10)),function(e){return e.keyCode===n?t.call(this,e):void 0}}},e.key.keyCodes=s,i.extend(e,n(52))},function(t,e,n){function i(t,e){if(r.isPlainObject(t)){for(var n in t)if(i(t[n],e))return!0}else if(r.isArray(t)){for(var s=t.length;s--;)if(i(t[s],e))return!0}else if(null!=t)return t.toString().toLowerCase().indexOf(e)>-1}var r=n(2),s=n(17);e.filterBy=function(t,e,n,r){return n&&"in"!==n&&(r=n),e?(e=(""+e).toLowerCase(),t.filter(function(t){return r?i(s.get(t,r),e):i(t,e)})):t},e.orderBy=function(t,e,n){if(!e)return t;var i=1;return arguments.length>2&&(i="-1"===n?-1:n?-1:1),t.slice().sort(function(t,n){return"$key"!==e&&"$value"!==e&&(t&&"$value"in t&&(t=t.$value),n&&"$value"in n&&(n=n.$value)),t=r.isObject(t)?s.get(t,e):t,n=r.isObject(n)?s.get(n,e):n,t===n?0:t>n?i:-i})}},function(t,e,n){var i=n(2).mergeOptions;e._init=function(t){t=t||{},this.$el=null,this.$parent=t._parent,this.$root=t._root||this,this.$={},this.$$={},this._watchers=[],this._directives=[],this._isVue=!0,this._events={},this._eventsCount={},this._eventCancelled=!1,this._isBlock=!1,this._blockStart=this._blockEnd=null,this._isCompiled=this._isDestroyed=this._isReady=this._isAttached=this._isBeingDestroyed=!1,this._unlinkFn=null,this._children=[],this._childCtors={},this._transCpnts=[],this._host=t._host,this.$parent&&this.$parent._children.push(this),this._host&&this._host._transCpnts.push(this),this._new=!0,this._reused=!1,t=this.$options=i(this.constructor.options,t,this),this._data=t.data||{},this._initScope(),this._initEvents(),this._callHook("created"),t.el&&this.$mount(t.el)}},function(t,e,n){function i(t,e,n){if(n){var i,s,o,a;for(s in n)if(i=n[s],c.isArray(i))for(o=0,a=i.length;a>o;o++)r(t,e,s,i[o]);else r(t,e,s,i)}}function r(t,e,n,i){var r=typeof i;if("function"===r)t[e](n,i);else if("string"===r){var s=t.$options.methods,o=s&&s[i];o&&t[e](n,o)}}function s(){this._isAttached=!0,this._children.forEach(o),this._transCpnts.length&&this._transCpnts.forEach(o)}function o(t){!t._isAttached&&l(t.$el)&&t._callHook("attached")}function a(){this._isAttached=!1,this._children.forEach(h),this._transCpnts.length&&this._transCpnts.forEach(h)}function h(t){t._isAttached&&!l(t.$el)&&t._callHook("detached")}var c=n(2),l=c.inDoc;e._initEvents=function(){var t=this.$options;i(this,"$on",t.events),i(this,"$watch",t.watch)},e._initDOMHooks=function(){this.$on("hook:attached",s),this.$on("hook:detached",a)},e._callHook=function(t){var e=this.$options[t];if(e)for(var n=0,i=e.length;i>n;n++)e[n].call(this);this.$emit("hook:"+t)}},function(t,e,n){function i(){}var r=n(2),s=n(12),o=n(13);e._initScope=function(){this._initData(),this._initComputed(),this._initMethods(),this._initMeta()},e._initData=function(){var t,e,n=this._data,i=this.$options.props;if(i)for(t=i.length;t--;)e=r.camelize(i[t]),e in n||(n[e]=null);var o=Object.keys(n);for(t=o.length;t--;)e=o[t],r.isReserved(e)||this._proxy(e);s.create(n).addVm(this)},e._setData=function(t){t=t||{};var e=this._data;this._data=t;var n,i,o,a=this.$options.props;if(a)for(o=a.length;o--;)i=a[o],t.$set(i,e[i]);for(n=Object.keys(e),o=n.length;o--;)i=n[o],r.isReserved(i)||i in t||this._unproxy(i);for(n=Object.keys(t),o=n.length;o--;)i=n[o],this.hasOwnProperty(i)||r.isReserved(i)||this._proxy(i);e.__ob__.removeVm(this),s.create(t).addVm(this),this._digest()},e._proxy=function(t){var e=this;Object.defineProperty(e,t,{configurable:!0,enumerable:!0,get:function(){return e._data[t]},set:function(n){e._data[t]=n}})},e._unproxy=function(t){delete this[t]},e._digest=function(){for(var t=this._watchers.length;t--;)this._watchers[t].update();var e=this._children;for(t=e.length;t--;){var n=e[t];n.$options.inherit&&n._digest()}},e._initComputed=function(){var t=this.$options.computed;if(t)for(var e in t){var n=t[e],s={enumerable:!0,configurable:!0};"function"==typeof n?(s.get=r.bind(n,this),s.set=i):(s.get=n.get?r.bind(n.get,this):i,s.set=n.set?r.bind(n.set,this):i),Object.defineProperty(this,e,s)}},e._initMethods=function(){var t=this.$options.methods;if(t)for(var e in t)this[e]=r.bind(t[e],this)},e._initMeta=function(){var t=this.$options._meta;if(t)for(var e in t)this._defineMeta(e,t[e])},e._defineMeta=function(t,e){var n=new o;Object.defineProperty(this,t,{enumerable:!0,configurable:!0,get:function(){return s.target&&s.target.addDep(n),e},set:function(t){t!==e&&(e=t,n.notify())}})}},function(t,e,n){var i=n(2);e._applyFilters=function(t,e,n,r){var s,o,a,h,c,l,u,f,d;for(l=0,u=n.length;u>l;l++)if(s=n[l],o=i.resolveAsset(this.$options,"filters",s.name),o&&(o=r?o.write:o.read||o,"function"==typeof o)){if(a=r?[t,e]:[t],c=r?2:1,s.args)for(f=0,d=s.args.length;d>f;f++)h=s.args[f],a[f+c]=h.dynamic?this.$get(h.value):h.value;t=o.apply(this,a)}return t},e._resolveComponent=function(t,e){var n=i.resolveAsset(this.$options,"components",t);if(n.options)e(n);else if(n.resolved)e(n.resolved);else if(n.requested)n.pendingCallbacks.push(e);else{n.requested=!0;var r=n.pendingCallbacks=[e];n(function(t){i.isPlainObject(t)&&(t=i.Vue.extend(t)),n.resolved=t;for(var e=0,s=r.length;s>e;e++)r[e](t)})}}},function(t,e,n){var i=n(11),r=n(17),s=n(20),o=n(21),a=n(16),h=/[^|]\|[^|]/;e.$get=function(t){var e=a.parse(t);return e?e.get.call(this,this):void 0},e.$set=function(t,e){var n=a.parse(t,!0);n&&n.set&&n.set.call(this,this,e)},e.$add=function(t,e){this._data.$add(t,e)},e.$delete=function(t){this._data.$delete(t)},e.$watch=function(t,e,n,r){var s=this,o=function(t,n){e.call(s,t,n)},a=new i(s,t,o,{deep:n,user:!0});return r&&o(a.value),function(){a.teardown()}},e.$eval=function(t){if(h.test(t)){var e=o.parse(t)[0],n=this.$get(e.expression);return e.filters?this._applyFilters(n,null,e.filters):n}return this.$get(t)},e.$interpolate=function(t){var e=s.parse(t),n=this;return e?1===e.length?n.$eval(e[0].value):e.map(function(t){return t.tag?n.$eval(t.value):t.value}).join(""):t},e.$log=function(t){var e=t?r.get(this._data,t):this._data;e&&(e=JSON.parse(JSON.stringify(e))),console.log(e)}},function(t,e,n){function i(t,e,n,i,o,a){e=s(e);var h=!c.inDoc(e),l=i===!1||h?o:a,u=!h&&!t._isAttached&&!c.inDoc(t.$el);return t._isBlock?r(t,e,l,n):l(t.$el,e,t,n),u&&t._callHook("attached"),t}function r(t,e,n,i){for(var r,s=t._blockStart,o=t._blockEnd;r!==o;)r=s.nextSibling,n(s,e,t),s=r;n(o,e,t,i)}function s(t){return"string"==typeof t?document.querySelector(t):t}function o(t,e,n,i){e.appendChild(t),i&&i()}function a(t,e,n,i){c.before(t,e),i&&i()}function h(t,e,n){c.remove(t),n&&n()}var c=n(2),l=n(33);e.$nextTick=function(t){c.nextTick(t,this)},e.$appendTo=function(t,e,n){return i(this,t,e,n,o,l.append)},e.$prependTo=function(t,e,n){return t=s(t),t.hasChildNodes()?this.$before(t.firstChild,e,n):this.$appendTo(t,e,n),this},e.$before=function(t,e,n){return i(this,t,e,n,a,l.before)},e.$after=function(t,e,n){return t=s(t),t.nextSibling?this.$before(t.nextSibling,e,n):this.$appendTo(t.parentNode,e,n),this},e.$remove=function(t,e){var n=this._isAttached&&c.inDoc(this.$el);n||(e=!1);var i,s=this,a=function(){n&&s._callHook("detached"),t&&t()};return this._isBlock&&!this._blockFragment.hasChildNodes()?(i=e===!1?o:l.removeThenAppend,r(this,this._blockFragment,i,a)):(i=e===!1?h:l.remove)(this.$el,this,a),this}},function(t,e,n){function i(t,e,n){var i=t.$parent;if(i&&n&&!s.test(e))for(;i;)i._eventsCount[e]=(i._eventsCount[e]||0)+n,i=i.$parent}var r=n(2);e.$on=function(t,e){return(this._events[t]||(this._events[t]=[])).push(e),i(this,t,1),this},e.$once=function(t,e){function n(){i.$off(t,n),e.apply(this,arguments)}var i=this;return n.fn=e,this.$on(t,n),this},e.$off=function(t,e){var n;if(!arguments.length){if(this.$parent)for(t in this._events)n=this._events[t],n&&i(this,t,-n.length);return this._events={},this}if(n=this._events[t],!n)return this;if(1===arguments.length)return i(this,t,-n.length),this._events[t]=null,this;for(var r,s=n.length;s--;)if(r=n[s],r===e||r.fn===e){i(this,t,-1),n.splice(s,1);break}return this},e.$emit=function(t){this._eventCancelled=!1;var e=this._events[t];if(e){for(var n=arguments.length-1,i=new Array(n);n--;)i[n]=arguments[n+1];n=0,e=e.length>1?r.toArray(e):e;for(var s=e.length;s>n;n++)e[n].apply(this,i)===!1&&(this._eventCancelled=!0)}return this},e.$broadcast=function(t){if(this._eventsCount[t]){for(var e=this._children,n=0,i=e.length;i>n;n++){var r=e[n];r.$emit.apply(r,arguments),r._eventCancelled||r.$broadcast.apply(r,arguments)}return this}},e.$dispatch=function(){for(var t=this.$parent;t;)t.$emit.apply(t,arguments),t=t._eventCancelled?null:t.$parent;return this};var s=/^hook:/},function(t,e,n){var i=n(2);e.$addChild=function(t,e){e=e||i.Vue,t=t||{};var n,r=this,s=void 0!==t.inherit?t.inherit:e.options.inherit;if(s){var o=r._childCtors;if(n=o[e.cid],!n){var a=e.options.name,h=a?i.classify(a):"VueComponent";n=new Function("return function "+h+" (options) {this.constructor = "+h+";this._init(options) }")(),n.options=e.options,n.prototype=this,o[e.cid]=n}}else n=e;t._parent=r,t._root=r.$root;var c=new n(t);return c}},function(t,e,n){function i(){this._isAttached=!0,this._isReady=!0,this._callHook("ready")}var r=n(2),s=n(22);e.$mount=function(t){if(!this._isCompiled){if(t){if("string"==typeof t){if(t=document.querySelector(t),!t)return}}else t=document.createElement("div");return this._compile(t),this._isCompiled=!0,this._callHook("compiled"),r.inDoc(this.$el)?(this._callHook("attached"),this._initDOMHooks(),i.call(this)):(this._initDOMHooks(),this.$once("hook:attached",i)),this}},e.$destroy=function(t,e){this._destroy(t,e)},e.$compile=function(t){return s(t,this.$options,!0)(this,t);
+}}])});
\ No newline at end of file
diff --git a/package.json b/package.json
index 036c7b7c67c..3a3cdfafdfd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "0.12.0-beta5",
+  "version": "0.12.0-rc",
   "author": "Evan You <yyx990803@gmail.com>",
   "license": "MIT",
   "description": "Simple, Fast & Composable MVVM for building interative interfaces",